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})
