def test_project_validation(self, user_A): """ Test to demonstrate details bug on encode->decode. Test illustrates the ValidationException we see when Project is encoded to dict then decoded back to Project and saved. No exception is seen if the original Project is simply saved without encode & decode OR if the details are unloaded before saving """ conn = get_connection(user_A) project = ProjectI() project.name = rstring('test_project_validation') project = conn.getUpdateService().saveAndReturnObject(project) # Saving original Project again is OK conn.getUpdateService().saveObject(project) # encode and decode before Save raises Validation Exception project_json = get_encoder(project.__class__).encode(project) decoder = get_decoder(project_json['@type']) p = decoder.decode(project_json) with pytest.raises(ValidationException): conn.getUpdateService().saveObject(p) p = decoder.decode(project_json) # Unloading details allows Save without exception p.unloadDetails() conn.getUpdateService().saveObject(p)
def test_roi_delete(self, user1, image_rois): """Test GET and DELETE of a single ROI.""" image, rois = image_rois conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] # Before delete, we can read roi_id = rois[0].id.val roi_url = reverse('api_roi', kwargs={ 'api_version': version, 'object_id': roi_id }) rsp = get_json(client, roi_url) assert_objects(conn, [rsp['data']], rois[:1], dtype="Roi", opts={'load_shapes': True}) shape_json = rsp['data']['shapes'][0] shape_id = shape_json['@id'] shape_class = shape_json['@type'].split('#')[1] # e.g. Ellipse shape = conn.getQueryService().get(shape_class, shape_id) assert shape.id.val == shape_id # Delete delete_json(client, roi_url, {}) # Get should now return 404 rsp = get_json(client, roi_url, status_code=404) assert rsp['message'] == 'Roi %s not found' % roi_id # Check that Shape has also been deleted with pytest.raises(ValidationException): shape = conn.getQueryService().get(shape_class, shape_id)
def test_security_violation(self, group_B, user_A): """Test saving to incorrect group.""" conn = get_connection(user_A) group_A_id = conn.getEventContext().groupId userName = conn.getUser().getName() django_client = self.new_django_client(userName, userName) version = api_settings.API_VERSIONS[-1] group_B_id = group_B.id.val save_url = reverse('api_save', kwargs={'api_version': version}) # Create project in group_A (default group) payload = {'Name': 'test_security_violation', '@type': OME_SCHEMA_URL + '#Project'} save_url_grp_A = save_url + '?group=' + native_str(group_A_id) rsp = post_json(django_client, save_url_grp_A, payload, status_code=201) pr_json = rsp['data'] projectId = pr_json['@id'] # Try to save again into group B save_url_grp_B = save_url + '?group=' + native_str(group_B_id) rsp = put_json(django_client, save_url_grp_B, pr_json, status_code=403) assert 'message' in rsp msg = "Cannot read ome.model.containers.Project:Id_%s" % projectId assert msg in rsp['message'] assert rsp['stacktrace'].startswith( 'Traceback (most recent call last):')
def test_validation_exception(self, user_A): """Test handling when we try to save something invalid.""" conn = get_connection(user_A) group = conn.getEventContext().groupId userName = conn.getUser().getName() django_client = self.new_django_client(userName, userName) version = api_settings.API_VERSIONS[-1] save_url = reverse('api_save', kwargs={'api_version': version}) save_url += '?group=' + native_str(group) # Create Tag tag = TagAnnotationI() tag.textValue = rstring('test_tag') tag = conn.getUpdateService().saveAndReturnObject(tag) tag_json = {'Value': 'test_tag', '@id': tag.id.val, '@type': OME_SCHEMA_URL + '#TagAnnotation'} # Add Tag twice to Project to get Validation Exception payload = {'Name': 'test_validation', '@type': OME_SCHEMA_URL + '#Project', 'Annotations': [tag_json, tag_json]} rsp = post_json(django_client, save_url, payload, status_code=400) # NB: message contains whole stack trace assert "ValidationException" in rsp['message'] assert rsp['stacktrace'].startswith( 'Traceback (most recent call last):')
def test_screens(self, user1, user_screens): """Test listing of Screens.""" conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] request_url = reverse('api_screens', kwargs={'api_version': version}) # List ALL Screens rsp = get_json(client, request_url) extra = [] for screen in user_screens: s_url = build_url(client, 'api_screen', { 'api_version': version, 'object_id': screen.id.val }) p_url = build_url(client, 'api_screen_plates', { 'api_version': version, 'screen_id': screen.id.val }) extra.append({'url:screen': s_url, 'url:plates': p_url}) assert_objects(conn, rsp['data'], user_screens, dtype="Screen", extra=extra)
def test_filter_groups(self, user1): """ Test filtering groups by experimenter """ conn = get_connection(user1) user_name = conn.getUser().getName() user_id = conn.getUserId() group_id = conn.getEventContext().groupId django_client = self.new_django_client(user_name, user_name) request_url = reverse( 'api_experimentergroups', kwargs={'api_version': api_settings.API_VERSIONS[-1]}) # Test /experimentergroups/?experimenter=1 data = {'experimenter': user_id} rsp = get_json(django_client, request_url, data) groups_json = rsp['data'] # user1 is in a single group AND the 'user' group assert len(groups_json) == 2 user_group_id = conn.getAdminService().getSecurityRoles().userGroupId user_group = [g for g in groups_json if g["@id"] == user_group_id] assert user_group[0]['Name'] == 'user' other_group = [g for g in groups_json if g["@id"] != user_group_id] assert other_group[0]['Name'] == conn.getGroupFromContext().name assert other_group[0]['@id'] == group_id # Test same result with experimenters/1/experimentergroups/ request_url = reverse('api_experimenter_experimentergroups', kwargs={ 'api_version': api_settings.API_VERSIONS[-1], 'experimenter_id': user_id }) rsp = get_json(django_client, request_url) groups_json2 = rsp['data'] assert groups_json == groups_json2
def test_filter_experimenters(self, user1): """ Test filtering experimenters by group """ conn = get_connection(user1) user_name = conn.getUser().getName() user_id = conn.getUserId() group_id = conn.getEventContext().groupId django_client = self.new_django_client(user_name, user_name) request_url = reverse( 'api_experimenters', kwargs={'api_version': api_settings.API_VERSIONS[-1]}) # Test /experimenters/?experimentergroup=1 data = {'experimentergroup': group_id} rsp = get_json(django_client, request_url, data) exps_json = rsp['data'] # user1 is in a single group AND the 'user' group assert len(exps_json) == 1 assert exps_json[0]['@id'] == user_id assert exps_json[0]['UserName'] == user_name # Test same result with experimentergroups/1/experimenters/ request_url = reverse('api_experimentergroup_experimenters', kwargs={ 'api_version': api_settings.API_VERSIONS[-1], 'group_id': group_id }) rsp = get_json(django_client, request_url) exps_json2 = rsp['data'] assert exps_json == exps_json2
def test_container_tags_update(self, user1, dtype): """ Test updating a Object without losing linked Tags. If we load a Object without loading Annotations, then update and save the Object, we don't want to lose Annotation links """ conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) container = dtype[1]() container.name = rstring('test_container_tags_update') tag = TagAnnotationI() tag.textValue = rstring('tag') container.linkAnnotation(tag) container = get_update_service(user1).saveAndReturnObject(container) version = api_settings.API_VERSIONS[-1] object_url = reverse('api_%s' % dtype[0], kwargs={ 'api_version': version, 'object_id': container.id.val }) save_url = reverse('api_save', kwargs={'api_version': version}) # Get container, update and save back rsp = get_json(django_client, object_url) object_json = rsp['data'] object_json['Name'] = 'renamed container' put_json(django_client, save_url, object_json) # Check container has been updated and still has annotation links proj = conn.getObject(dtype[0], container.id.val) assert proj.getName() == 'renamed container' assert len(list(proj.listAnnotations())) == 1
def test_shapes(self, user1, image_rois, shapes): """Test listing Shapes""" image, rois = image_rois conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] # List ALL shapes shapes_url = reverse('api_shapes', kwargs={'api_version': version}) rsp = get_json(client, shapes_url) shapes_json = rsp['data'] shape_ids = [shape['@id'] for shape in shapes_json] assert len(shape_ids) == len(shapes) assert_objects(conn, shapes_json, shape_ids, dtype="Shape") for shape_id in shape_ids: # Get a single Shape url = reverse('api_shape', kwargs={ 'api_version': version, 'object_id': shape_id }) rsp = get_json(client, url, {'image': image.id.val}) assert_objects(conn, [rsp['data']], [shape_id], dtype="Shape")
def test_pdi_parent_urls(self, user1, project_datasets): """Test browsing via urls in json /api/image -> project.""" conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] # Get image... project, dataset = project_datasets datasets = project.linkedDatasetList() datasets.sort(key=lambda x: lower_or_none(unwrap(x.name))) # ...from last dataset images = datasets[-1].linkedImageList() dataset_id = datasets[-1].id.val # Listing images - all have link to parents imgs_url = reverse('api_images', kwargs={'api_version': version}) rsp = get_json(client, imgs_url, {'dataset': dataset_id}) for i in rsp['data']: datasets_url = build_url(client, 'api_image_datasets', {'api_version': version, 'image_id': i['@id']}) assert i['url:datasets'] == datasets_url # Single Image has link to parents... img_url = imgs_url + '%s/' % images[0].id.val rsp = get_json(client, img_url) img_json = rsp['data'] image_datasets_url = build_url(client, 'api_image_datasets', {'api_version': version, 'image_id': images[0].id.val}) assert img_json['url:datasets'] == image_datasets_url # List parent datasets rsp = get_json(client, image_datasets_url) assert_objects(conn, rsp['data'], [datasets[-1]], dtype='Dataset') # Listing Datasets (in Project) - all have link to parents datasets_url = reverse('api_datasets', kwargs={'api_version': version}) rsp = get_json(client, datasets_url, {'project': project.id.val}) for d in rsp['data']: projects_url = build_url(client, 'api_dataset_projects', {'api_version': version, 'dataset_id': d['@id']}) assert d['url:projects'] == projects_url # Single Dataset has link to parents... dataset_url = datasets_url + '%s/' % dataset_id rsp = get_json(client, dataset_url) dataset_json = rsp['data'] dataset_projects_url = build_url(client, 'api_dataset_projects', {'api_version': version, 'dataset_id': dataset_id}) assert dataset_json['url:projects'] == dataset_projects_url # List parent Projects rsp = get_json(client, dataset_projects_url) assert_objects(conn, rsp['data'], [project])
def test_create_update_unsupported(self, user1, dtype, method): """Test create and update are rejected for unsupported types.""" conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] save_url = reverse('api_save', kwargs={'api_version': version}) payload = {'Name': 'test', '@type': OME_SCHEMA_URL + '#%s' % dtype} # Test PUT/POST rsp = method[0](django_client, save_url, payload, status_code=405) assert rsp['message'] == '%s of %s not supported' % (method[1], dtype)
def test_delete_unsupported(self, user1, dtype): """Test delete is rejected for unsupported types.""" conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] # Delete (fake url - image doesn't need to exist for test) url_name = 'api_%s' % dtype.lower() delete_url = reverse(url_name, kwargs={'api_version': version, 'object_id': 1}) rsp = delete_json(django_client, delete_url, status_code=405) assert rsp['message'] == 'Delete of %s not supported' % dtype
def test_spw_parent_urls(self, user1, screen_plates): """Test browsing via urls in json /api/image -> well, plate, screen.""" conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] screen, plate = screen_plates plates = screen.linkedPlateList() plates.sort(cmp_name_insensitive) # Listing wells - all have link to parents wells_url = reverse('api_wells', kwargs={'api_version': version}) rsp = get_json(client, wells_url) for w in rsp['data']: plates_url = build_url(client, 'api_well_plates', { 'api_version': version, 'well_id': w['@id'] }) assert w['url:plates'] == plates_url # Single Well has link to parents... well_id = rsp['data'][0]['@id'] well_url = wells_url + '%s/' % well_id rsp = get_json(client, well_url) well_json = rsp['data'] well_plates_url = build_url(client, 'api_well_plates', { 'api_version': version, 'well_id': well_id }) assert well_json['url:plates'] == well_plates_url # Get parent plate (Plates list, filtered by Well) print 'well_plates_url', well_plates_url rsp = get_json(client, well_plates_url) plates_json = rsp['data'] # check for link to Screen screens_url = build_url(client, 'api_plate_screens', { 'api_version': version, 'plate_id': plates_json[0]['@id'] }) assert plates_json[0]['url:screens'] == screens_url plate_url = plates_json[0]['url:plate'] assert_objects(conn, plates_json, [plates[0]], dtype='Plate') # Get the same Plate by ID rsp = get_json(client, plate_url) assert rsp['data']['url:screens'] == screens_url # Get Screen rsp = get_json(client, screens_url) assert_objects(conn, rsp['data'], [screen], dtype='Screen')
def test_groups_experimenters(self, user1): """ Test listing groups. We simply list existing Groups since we have no way to filter and show only those created in the test. """ conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) request_url = reverse( 'api_experimentergroups', kwargs={'api_version': api_settings.API_VERSIONS[-1]}) data = {'limit': 10} rsp = get_json(django_client, request_url, data) groups_json = rsp['data'] query = """select obj from ExperimenterGroup as obj order by lower(obj.name), obj.id""" params = ParametersI() params.page(0, 10) groups = conn.getQueryService().findAllByQuery(query, params) assert_objects(conn, groups_json, groups, dtype="ExperimenterGroup") # Check experimenters_url for all groups above for group_json in groups_json: # Check we can follow link to Experimenters for first Group expimenters_url = group_json["url:experimenters"] rsp = get_json(django_client, expimenters_url) exps_json = rsp['data'] exp_ids = [e['@id'] for e in exps_json] # Check if eids are same for group (won't be ordered) grp = conn.getObject("ExperimenterGroup", group_json['@id']) eids = [ link.child.id.val for link in grp.copyGroupExperimenterMap() ] assert set(eids) == set(exp_ids) if len(exp_ids) > 0: assert_objects(conn, exps_json, exp_ids, dtype="Experimenter")
def test_screen_plates_update(self, user1, screen_plates): """Test update of Screen doesn't break links to Plate.""" conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] screen = screen_plates[0] plate_count = len(screen.linkedPlateList()) screen_url = reverse('api_screen', kwargs={'api_version': version, 'object_id': screen.id.val}) save_url = reverse('api_save', kwargs={'api_version': version}) # Get Screen, update and save back rsp = get_json(django_client, screen_url) screen_json = rsp['data'] screen_json['Name'] = 'renamed Screen' put_json(django_client, save_url, screen_json) # Check Screen has been updated and still has child Plates scr = conn.getObject('Screen', screen.id.val) assert scr.getName() == 'renamed Screen' assert len(list(scr.listChildren())) == plate_count
def test_plate_wells(self, user1, small_plate, bigger_plate): """Test listing of Wells in a Plate.""" conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] wells_url = reverse('api_wells', kwargs={'api_version': version}) # List ALL Wells in both plates rsp = get_json(django_client, wells_url) assert len(rsp['data']) == 8 # Filter Wells by Plate for plate, with_acq, well_count in zip([small_plate, bigger_plate], [False, True], [2, 6]): # Use Blitz Plates for listing Wells etc. plate_wrapper = conn.getObject('Plate', plate.id.val) wells = [w._obj for w in plate_wrapper.listChildren()] wells.sort(key=lambda x: column_row_key(x)) payload = {'plate': plate.id.val} rsp = get_json(django_client, wells_url, payload) # Manual check that Images are loaded but Pixels are not assert len(rsp['data']) == well_count assert rsp['meta']['totalCount'] == well_count well_sample = rsp['data'][0]['WellSamples'][0] assert 'Image' in well_sample assert ('PlateAcquisition' in well_sample) == with_acq assert 'Pixels' not in well_sample['Image'] extra = [{'url:well': build_url(django_client, 'api_well', {'object_id': w.id.val, 'api_version': version})} for w in wells] assert_objects(conn, rsp['data'], wells, dtype='Well', opts={'load_images': True}, extra=extra)
def test_experimenters_groups(self, user1): """ Test listing experimenters. We simply list existing Experimenters since we have no way to filter and show only those created in the test. """ conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) request_url = reverse( 'api_experimenters', kwargs={'api_version': api_settings.API_VERSIONS[-1]}) data = {'limit': 10} rsp = get_json(django_client, request_url, data) exp_json = rsp['data'] query = """select obj from Experimenter as obj order by lower(obj.lastName), lower(obj.firstName), obj.id""" params = ParametersI() params.page(0, 10) exps = conn.getQueryService().findAllByQuery(query, params) assert_objects(conn, exp_json, exps, dtype="Experimenter") # Check we can follow link to Groups for first Experimenter groups_url = exp_json[0]["url:experimentergroups"] rsp = get_json(django_client, groups_url) groups_json = rsp['data'] grp_ids = [g['@id'] for g in groups_json] # Check if gids are same for experimenter (won't be ordered) gids = [g.id for g in conn.getOtherGroups(exp_json[0]['@id'])] assert set(gids) == set(grp_ids) assert_objects(conn, groups_json, grp_ids, dtype="ExperimenterGroup")
def test_image_rois(self, user1, image_rois): """Test listing ROIs and filtering by Image.""" image, rois = image_rois conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] # List ALL rois rois_url = reverse('api_rois', kwargs={'api_version': version}) rsp = get_json(client, rois_url) assert_objects(conn, rsp['data'], rois, dtype="Roi", opts={'load_shapes': True}) # ROIs on the image rsp = get_json(client, rois_url, {'image': image.id.val}) assert_objects(conn, rsp['data'], rois[:2], dtype="Roi", opts={'load_shapes': True})
def test_well(self, user1, small_plate): """Test loading a single Well, with or without WellSamples.""" conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] small_plate = conn.getObject('Plate', small_plate.id.val) wells = [w._obj for w in small_plate.listChildren()] wells.sort(key=lambda x: column_row_key(x)) # plate has 2 wells. First has WellSamples, other doesn't for well, has_image in zip(wells, [True, False]): well_url = reverse('api_well', kwargs={'api_version': version, 'object_id': well.id.val}) rsp = get_json(django_client, well_url) well_json = rsp['data'] # Manually check for image and Pixels loaded assert ('WellSamples' in well_json) == has_image if has_image: assert len(well_json['WellSamples']) == 3 assert 'Pixels' in well_json['WellSamples'][0]['Image'] assert_objects(conn, [well_json], [well], dtype='Well', opts={'load_pixels': True})
def test_pdi_urls(self, user1, project_datasets): """Test browsing via urls in json /api/->PDI.""" conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] base_url = reverse('api_base', kwargs={'api_version': version}) base_rsp = get_json(client, base_url) # List projects project, dataset = project_datasets projects_url = base_rsp['url:projects'] rsp = get_json(client, projects_url) projects_json = rsp['data'] extra = [{ 'url:project': build_url(client, 'api_project', { 'api_version': version, 'object_id': project.id.val }), 'url:datasets': build_url(client, 'api_project_datasets', { 'api_version': version, 'project_id': project.id.val }) }] assert_objects(conn, projects_json, [project], extra=extra) # View single Project rsp = get_json(client, projects_json[0]['url:project']) assert_objects(conn, [rsp['data']], [project], extra=[{ 'url:datasets': extra[0]['url:datasets'] }]) # List datasets datasets_url = projects_json[0]['url:datasets'] datasets = project.linkedDatasetList() datasets.sort(cmp_name_insensitive) rsp = get_json(client, datasets_url) datasets_json = rsp['data'] extra = [] for d in datasets: extra.append({ 'url:dataset': build_url(client, 'api_dataset', { 'api_version': version, 'object_id': d.id.val }), 'url:images': build_url(client, 'api_dataset_images', { 'api_version': version, 'dataset_id': d.id.val }) }) assert_objects(conn, datasets_json, datasets, dtype='Dataset', extra=extra) # View single Dataset rsp = get_json(client, datasets_json[0]['url:dataset']) assert_objects(conn, [rsp['data']], datasets[0:1], dtype='Dataset', extra=[{ 'url:images': extra[0]['url:images'] }]) # List images (from last Dataset) images_url = datasets_json[-1]['url:images'] images = datasets[-1].linkedImageList() images.sort(cmp_name_insensitive) rsp = get_json(client, images_url) images_json = rsp['data'] extra = [] for i in images: extra.append({ 'url:image': build_url(client, 'api_image', { 'api_version': version, 'object_id': i.id.val }), }) assert_objects(conn, images_json, images, dtype='Image', extra=extra, opts={'load_pixels': True}) # View single Image rsp = get_json(client, images_json[0]['url:image']) assert_objects(conn, [rsp['data']], images[0:1], dtype='Image', opts={'load_channels': True})
def test_spw_urls(self, user1, screen_plates): """Test browsing via urls in json /api/->SPW.""" conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] base_url = reverse('api_base', kwargs={'api_version': version}) base_rsp = get_json(client, base_url) # List screens screen, plate = screen_plates screens_url = base_rsp['url:screens'] rsp = get_json(client, screens_url) screens_json = rsp['data'] extra = [{ 'url:screen': build_url(client, 'api_screen', { 'api_version': version, 'object_id': screen.id.val }), 'url:plates': build_url(client, 'api_screen_plates', { 'api_version': version, 'screen_id': screen.id.val }) }] assert_objects(conn, screens_json, [screen], dtype='Screen', extra=extra) # View single screen rsp = get_json(client, screens_json[0]['url:screen']) assert_objects(conn, [rsp['data']], [screen], dtype='Screen', extra=[{ 'url:plates': extra[0]['url:plates'] }]) # List plates plates_url = screens_json[0]['url:plates'] plates = screen.linkedPlateList() plates.sort(cmp_name_insensitive) rsp = get_json(client, plates_url) plates_json = rsp['data'] extra = [] for p in plates: extra.append({ 'url:plate': build_url(client, 'api_plate', { 'api_version': version, 'object_id': p.id.val }), 'url:wells': build_url(client, 'api_plate_wells', { 'api_version': version, 'plate_id': p.id.val }) }) assert_objects(conn, plates_json, plates, dtype='Plate', extra=extra) # View single plate rsp = get_json(client, plates_json[0]['url:plate']) plate_json = rsp['data'] minMaxIndex = [0, 0] links = [] for idx in range(minMaxIndex[0], minMaxIndex[1] + 1): l = build_url( client, 'api_plate_wellsampleindex_wells', { 'api_version': version, 'plate_id': plate_json['@id'], 'index': idx }) links.append(l) extra = [{ 'url:wellsampleindex_wells': links, 'omero:wellsampleIndex': minMaxIndex }] assert_objects(conn, [plate_json], plates[0:1], dtype='Plate', extra=extra) # List wells of first plate wells_url = plates_json[0]['url:wells'] rsp = get_json(client, wells_url) wells_json = rsp['data'] well_id = wells_json[0]['@id'] extra = [{ 'url:well': build_url(client, 'api_well', { 'api_version': version, 'object_id': well_id }) }] assert_objects(conn, wells_json, [well_id], dtype='Well', extra=extra, opts={'load_images': True}, client=client)
def django_client(self, user1): """Return new Django client.""" conn = get_connection(user1) user_name = conn.getUser().getName() return self.new_django_client(user_name, user_name)
def test_datasets_plates(self, user1, dtype, child_count, project_datasets, screen_plates): """Test listing of Datasets in a Project and Plates in Screen.""" conn = get_connection(user1) user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] # Handle parametrized dtype, setting up other variables if dtype == 'Dataset': parent = project_datasets[0] children = parent.linkedDatasetList() orphaned = project_datasets[1] url_name = 'api_datasets' ptype = 'project' # Counts of Images in Dataset / orphaned Dataset ds_or_pl_children = [{'omero:childCount': c} for c in range(5)] orph_ds_pl_children = [{'omero:childCount': 0}] pr_or_sc_children = [{'omero:childCount': 5}] else: parent = screen_plates[0] children = parent.linkedPlateList() orphaned = screen_plates[1] url_name = 'api_plates' ptype = 'screen' # Plates don't support childCount. ds_or_pl_children = None orph_ds_pl_children = None pr_or_sc_children = [{'omero:childCount': 5}] if not child_count: ds_or_pl_children = None orph_ds_pl_children = None pr_or_sc_children = None # Check child_count in Projects or Screens base_url = reverse('api_base', kwargs={'api_version': version}) parents_url = "%sm/%ss/" % (base_url, ptype) payload = {'childCount': str(child_count).lower()} rsp = get_json(django_client, parents_url, payload) assert_objects(conn, rsp['data'], [parent], dtype=ptype, extra=pr_or_sc_children) # And for single Project or Screen parent_url = "%sm/%ss/%s/" % (base_url, ptype, parent.id.val) rsp = get_json(django_client, parent_url, payload) assert_objects(conn, [rsp['data']], [parent], dtype=ptype, extra=pr_or_sc_children) request_url = reverse(url_name, kwargs={'api_version': version}) # List ALL Datasets or Plates rsp = get_json(django_client, request_url, payload) assert len(rsp['data']) == 6 assert rsp['meta'] == { 'totalCount': 6, 'limit': api_settings.API_LIMIT, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': 0 } # Filter Datasets or Plates by Orphaned payload = {'orphaned': 'true', 'childCount': str(child_count).lower()} rsp = get_json(django_client, request_url, payload) assert_objects(conn, rsp['data'], [orphaned], dtype=dtype, extra=orph_ds_pl_children) assert rsp['meta'] == { 'totalCount': 1, 'limit': api_settings.API_LIMIT, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': 0 } # Filter Datasets by Project or Plates by Screen children.sort(cmp_name_insensitive) payload = { ptype: parent.id.val, 'childCount': str(child_count).lower() } rsp = get_json(django_client, request_url, payload) assert len(rsp['data']) == 5 assert_objects(conn, rsp['data'], children, dtype=dtype, extra=ds_or_pl_children) assert rsp['meta'] == { 'totalCount': 5, 'limit': api_settings.API_LIMIT, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': 0 } # Single (first) Dataset or Plate payload = {'childCount': str(child_count).lower()} object_url = "%sm/%ss/%s/" % (base_url, dtype.lower(), children[0].id.val) rsp = get_json(django_client, object_url, payload) if dtype == 'Plate': # When we get a single Plate, expect this (not when listing plates) ds_or_pl_children = [{'omero:wellsampleIndex': [0, 0]}] assert_objects(conn, [rsp['data']], [children[0]], dtype=dtype, extra=ds_or_pl_children) # Pagination limit = 3 payload = { ptype: parent.id.val, 'limit': limit, 'childCount': str(child_count).lower() } rsp = get_json(django_client, request_url, payload) extra = None if ds_or_pl_children is not None and len(ds_or_pl_children) > 1: extra = ds_or_pl_children[0:limit] assert_objects(conn, rsp['data'], children[0:limit], dtype=dtype, extra=extra) assert rsp['meta'] == { 'totalCount': 5, 'limit': limit, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': 0 } payload['offset'] = limit # page 2 rsp = get_json(django_client, request_url, payload) if ds_or_pl_children is not None and len(ds_or_pl_children) > 1: extra = ds_or_pl_children[limit:limit * 2] assert_objects(conn, rsp['data'], children[limit:limit * 2], dtype=dtype, extra=extra) assert rsp['meta'] == { 'totalCount': 5, 'limit': limit, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': limit }
def test_plate_index_wells(self, user1, multi_acquisition_plate): """ Test filtering of Wells by Plate/PlateAcquisition AND index. Browse urls Plate -> PlateAcquisitions -> Wells OR Plate -> Wells (filtering by Index) """ conn = get_connection(user1) user_name = conn.getUser().getName() client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] plate_id = multi_acquisition_plate.id.val plate_url = reverse('api_plate', kwargs={'object_id': plate_id, 'api_version': version}) rsp = get_json(client, plate_url) plate_json = rsp['data'] # Construct the urls we expect... plate_acq_link = build_url(client, 'api_plate_plateacquisitions', {'plate_id': plate_id, 'api_version': version}) well_link = build_url(client, 'api_plate_wells', {'plate_id': plate_id, 'api_version': version}) index_links = [] plate = conn.getObject('Plate', plate_id) idx = plate.getNumberOfFields() for i in range(idx[0], idx[1]+1): link = build_url(client, 'api_plate_wellsampleindex_wells', {'api_version': version, 'plate_id': plate_id, 'index': i}) index_links.append(link) # ...and compare plate json: assert_objects(conn, [plate_json], [multi_acquisition_plate], dtype='Plate', extra=[{'url:plateacquisitions': plate_acq_link, 'url:wellsampleindex_wells': index_links, 'url:wells': well_link, 'omero:wellsampleIndex': list(idx)}]) # Browse to /plate/:id/plateacquisitions/ rsp = get_json(client, plate_acq_link) plate_acq_json = rsp['data'] # Construct data & urls we expect... pas = list(plate.listPlateAcquisitions()) pas.sort(key=lambda x: lower_or_none(unwrap(x.name))) paq_ids = [p.id for p in pas] extra = [] for p, plate_acq in enumerate(pas): index_links = [] for i in range(p * 3, (p + 1) * 3): link = build_url(client, 'api_plateacquisition_wellsampleindex_wells', {'api_version': version, 'plateacquisition_id': plate_acq.id, 'index': i}) index_links.append(link) extra.append({'url:wellsampleindex_wells': index_links, 'omero:wellsampleIndex': [p * 3, (p + 1) * 3 - 1]}) # ...and compare assert_objects(conn, plate_acq_json, paq_ids, dtype="PlateAcquisition", extra=extra)
def test_dataset_images(self, user1, dataset_images): """Test listing of Images in a Dataset.""" conn = get_connection(user1) group_id = conn.getEventContext().groupId user_name = conn.getUser().getName() django_client = self.new_django_client(user_name, user_name) version = api_settings.API_VERSIONS[-1] dataset = dataset_images[0] images = dataset.linkedImageList() orphaned = dataset_images[1] images_url = reverse('api_images', kwargs={'api_version': version}) datasets_url = reverse('api_datasets', kwargs={'api_version': version}) # List ALL Images rsp = get_json(django_client, images_url, {'group': group_id}) assert len(rsp['data']) == 6 assert rsp['meta'] == {'totalCount': 6, 'limit': api_settings.API_LIMIT, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': 0} # Filter Images by Orphaned payload = {'orphaned': 'true', 'group': group_id} rsp = get_json(django_client, images_url, payload) assert_objects(conn, rsp['data'], [orphaned], dtype='Image', group=group_id, opts={'load_pixels': True}) assert rsp['meta'] == {'totalCount': 1, 'limit': api_settings.API_LIMIT, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': 0} # Filter Images by Dataset images.sort(key=lambda x: lower_or_none(unwrap(x.name))) payload = {'dataset': dataset.id.val} rsp = get_json(django_client, images_url, payload) # Manual check that Pixels & Type are loaded but Channels are not assert 'Type' in rsp['data'][0]['Pixels'] assert 'Channels' not in rsp['data'][0]['Pixels'] assert_objects(conn, rsp['data'], images, dtype='Image', opts={'load_pixels': True}) assert rsp['meta'] == {'totalCount': 5, 'limit': api_settings.API_LIMIT, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': 0} # Pagination, listing images via /datasets/:id/images/ limit = 3 dataset_images_url = datasets_url + "%s/images/" % dataset.id.val payload = {'dataset': dataset.id.val, 'limit': limit} rsp = get_json(django_client, dataset_images_url, payload) assert_objects(conn, rsp['data'], images[0:limit], dtype='Image', opts={'load_pixels': True}) assert rsp['meta'] == {'totalCount': 5, 'limit': limit, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': 0} payload['offset'] = limit # page 2 rsp = get_json(django_client, images_url, payload) assert_objects(conn, rsp['data'], images[limit:limit * 2], dtype='Image', opts={'load_pixels': True}) assert rsp['meta'] == {'totalCount': 5, 'limit': limit, 'maxLimit': api_settings.API_MAX_LIMIT, 'offset': limit} # Show ONLY the orphaned image (channels are loaded by default) img_url = images_url + '%s/' % orphaned.id.val rsp = get_json(django_client, img_url) # Manual check that Channels are loaded img_json = rsp['data'] assert len(img_json['Pixels']['Channels']) == 1 assert_objects(conn, [img_json], [orphaned], dtype='Image', opts={'load_channels': True})