def test_ad_attr_merge(self, api_factory):
api_instance = api_factory.AssayDataApi()
try:
ident1 = openapi_client.Attr(attr_type='oxford_id',
attr_value='1234')
ident2 = openapi_client.Attr(attr_type='roma_id',
attr_value='12345')
ident3 = openapi_client.Attr(attr_type='lims_id',
attr_value='123456')
samp1 = openapi_client.AssayDatum(None)
samp1.attrs = [ident1]
created1 = api_instance.create_assay_datum(samp1)
samp2 = openapi_client.AssayDatum(None)
samp2.attrs = [ident2]
created2 = api_instance.create_assay_datum(samp2)
samp3 = openapi_client.AssayDatum(None)
samp3.attrs = [ident1, ident2, ident3]
with pytest.raises(ApiException, status=422):
created3 = api_instance.create_assay_datum(samp3)
api_instance.delete_assay_datum(created1.assay_datum_id)
api_instance.delete_assay_datum(created2.assay_datum_id)
except ApiException as error:
self.check_api_exception(api_factory,
"AssayDataApi->create_assay_datum", error)
def test_update_attrs(self, api_factory):
api_instance = api_factory.LocationApi()
try:
loc = self.get_next_location()
loc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='bhutan', study_name='1234-PV')
]
created = api_instance.create_location(loc)
looked_up_locs = api_instance.download_partner_location(loc.attrs[0].attr_value)
looked_up = looked_up_locs.locations[0]
newloc = copy.deepcopy(loc)
newloc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='nepal', study_name='1235-PV')
]
updated = api_instance.update_location(looked_up.location_id, newloc)
fetched = api_instance.download_location(looked_up.location_id)
assert updated == fetched, "update response != download response"
fetched.location_id = None
assert newloc == fetched, "update != download response"
api_instance.delete_location(looked_up.location_id)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def test_ds_attr_merge(self, api_factory):
api_instance = api_factory.DerivativeSampleApi()
try:
ident1 = openapi_client.Attr(attr_type='oxford_id',
attr_value='1234')
ident2 = openapi_client.Attr(attr_type='roma_id',
attr_value='12345')
ident3 = openapi_client.Attr(attr_type='lims_id',
attr_value='123456')
samp1 = openapi_client.DerivativeSample(None)
samp1.attrs = [ident1]
created1 = api_instance.create_derivative_sample(samp1)
samp2 = openapi_client.DerivativeSample(None)
samp2.attrs = [ident2]
created2 = api_instance.create_derivative_sample(samp2)
samp3 = openapi_client.DerivativeSample(None)
samp3.attrs = [ident1, ident2, ident3]
with pytest.raises(ApiException, status=422):
created3 = api_instance.create_derivative_sample(samp3)
api_instance.delete_derivative_sample(
created1.derivative_sample_id)
api_instance.delete_derivative_sample(
created2.derivative_sample_id)
except ApiException as error:
self.check_api_exception(
api_factory, "DerivativeSampleApi->create_derivative_sample",
error)
def test_ad_update_duplicate(self, api_factory):
api_instance = api_factory.AssayDataApi()
try:
samp = openapi_client.AssayDatum(None)
samp.attrs = [
openapi_client.Attr(attr_type='oxford',
attr_value='12345678',
attr_source='upd')
]
created = api_instance.create_assay_datum(samp)
looked_up = api_instance.download_assay_data_by_attr(
'oxford', '12345678')
looked_up = looked_up.assay_data[0]
new_samp = openapi_client.AssayDatum(None)
new_samp.attrs = [
openapi_client.Attr(attr_type='oxford',
attr_value='123456789',
attr_source='upd')
]
new_created = api_instance.create_assay_datum(new_samp)
with pytest.raises(ApiException, status=422):
updated = api_instance.update_assay_datum(
looked_up.assay_datum_id, new_samp)
api_instance.delete_assay_datum(looked_up.assay_datum_id)
api_instance.delete_assay_datum(new_created.assay_datum_id)
except ApiException as error:
self.check_api_exception(api_factory,
"AssayDataApi->create_assay_datum", error)
def create_derivative_sample_from_values(self, values):
d_sample = openapi_client.DerivativeSample(None)
idents = []
if 'derivative_sample_id' in values:
idents.append(
openapi_client.Attr('derivative_sample_id',
values['derivative_sample_id'],
self._event_set))
if 'derivative_sample_source' in values:
idents.append(
openapi_client.Attr('derivative_sample_source',
values['derivative_sample_source'],
self._event_set))
if 'sanger_sample_id' in values:
idents.append(
openapi_client.Attr('sanger_sample_id',
values['sanger_sample_id'],
self._event_set))
if 'sample_lims_id' in values and values['sample_lims_id']:
idents.append(
openapi_client.Attr('sanger_lims_id', values['sample_lims_id'],
self._event_set))
if 'dna_prep' in values:
d_sample.dna_prep = values['dna_prep']
d_sample.attrs = idents
return d_sample
def test_partner_lookup_multiple(self, api_factory):
api_instance = api_factory.LocationApi()
try:
loc = self.get_next_location()
loc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='bhutan', study_name='5000-PV')
]
created = api_instance.create_location(loc)
loc1 = self.get_next_location()
loc1.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='bhutan', study_name='5001-PV')
]
created1 = api_instance.create_location(loc1)
looked_up_locs = api_instance.download_partner_location(loc.attrs[0].attr_value)
assert looked_up_locs.count == 2, 'Wrong number of locations'
looked_up = looked_up_locs.locations[0]
api_instance.delete_location(created.location_id)
api_instance.delete_location(created1.location_id)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def test_duplicate_partner_name(self, api_factory):
api_instance = api_factory.LocationApi()
try:
loc = self.get_next_location()
loc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='Kobeni', study_name='5002-PF-MR-ANON'),
]
loc1 = openapi_client.Location(None, 28.46362, 91.49542, 'country',
'Trongsa, Trongsa, Bhutan', 'pv_3_locations.txt', 'BTN')
loc1.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='Kobeni', study_name='5002-PF-MR-ANON'),
]
created = api_instance.create_location(loc)
created1 = api_instance.create_location(loc1)
assert created.location_id != created1.location_id
api_instance.delete_location(created.location_id)
api_instance.delete_location(created1.location_id)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def create_location_from_values(self, values, prefix):
if prefix + 'location_name' not in values:
#print("No {}location name: {}".format(prefix, values))
return None, None
partner_name = values[prefix + 'location_name']
if not partner_name:
if prefix + 'latitude' in values and values[prefix + 'latitude']:
self.report("No location name: ", values)
return None, None
#Will have been set to 0000 if not present
if 'study_id' in values:
study_id = values['study_id'][:4]
loc = openapi_client.Location(None)
loc.attrs = [
openapi_client.Attr(attr_type='partner_name',
attr_value=partner_name,
attr_source=self._event_set,
study_name=study_id)
]
if prefix + "src_location_id" in values:
src_lid = openapi_client.Attr(attr_type='src_location_id',
attr_value=values[prefix +
'src_location_id'],
attr_source=self._event_set,
study_name=study_id)
loc.attrs.append(src_lid)
try:
if prefix + 'latitude' in values and values[prefix + 'latitude']:
loc.latitude = round(
float(Decimal(values[prefix + 'latitude'])), 7)
if prefix + 'longitude' in values and values[prefix + 'longitude']:
loc.longitude = round(
float(Decimal(values[prefix + 'longitude'])), 7)
except Exception as excp:
print(excp)
pass
if prefix + 'resolution' in values:
loc.accuracy = values[prefix + 'resolution']
if prefix + 'country' in values:
loc.country = values[prefix + 'country']
if 'description' in values:
loc.notes = self._event_set + ' ' + values['description']
else:
loc.notes = self._event_set
#print(values)
#print(loc)
return partner_name, loc
def test_ds_os_attr_lookup(self, api_factory):
api_instance = api_factory.OriginalSampleApi()
ds_api_instance = api_factory.DerivativeSampleApi()
try:
samp = openapi_client.OriginalSample(None, study_name='7000-MD-UP')
samp.attrs = [
openapi_client.Attr(attr_type='ds_os_attr',
attr_value='123456')
]
created = api_instance.create_original_sample(samp)
samp1 = openapi_client.DerivativeSample(None)
samp2 = openapi_client.DerivativeSample(None)
samp1.attrs = [
openapi_client.Attr(attr_type='test1',
attr_value='test1',
attr_source='ds_os_attr')
]
samp2.attrs = [
openapi_client.Attr(attr_type='test2',
attr_value='test2',
attr_source='ds_os_attr')
]
samp1.original_sample_id = created.original_sample_id
samp2.original_sample_id = created.original_sample_id
created1 = ds_api_instance.create_derivative_sample(samp1)
created2 = ds_api_instance.create_derivative_sample(samp2)
results = ds_api_instance.download_derivative_samples_by_os_attr(
'ds_os_attr', '123456')
assert results.count == 2
assert results.derivative_samples[
0].derivative_sample_id != results.derivative_samples[
1].derivative_sample_id
assert results.derivative_samples[
0].original_sample_id == results.derivative_samples[
1].original_sample_id
assert results.derivative_samples[
0].original_sample_id == created.original_sample_id
ds_api_instance.delete_derivative_sample(
created1.derivative_sample_id)
ds_api_instance.delete_derivative_sample(
created2.derivative_sample_id)
api_instance.delete_original_sample(created.original_sample_id)
except ApiException as error:
self.check_api_exception(
api_factory, "OriginalSampleApi->create_original_sample",
error)
def test_ad_update(self, api_factory):
api_instance = api_factory.AssayDataApi()
try:
samp = openapi_client.AssayDatum(None)
samp.attrs = [
openapi_client.Attr(attr_type='oxford', attr_value='1234567')
]
created = api_instance.create_assay_datum(samp)
looked_up = api_instance.download_assay_data_by_attr(
'oxford', '1234567')
looked_up = looked_up.assay_data[0]
new_samp = openapi_client.AssayDatum(None)
updated = api_instance.update_assay_datum(looked_up.assay_datum_id,
new_samp)
fetched = api_instance.download_assay_datum(
looked_up.assay_datum_id)
assert updated == fetched, "update response != download response"
fetched.assay_datum_id = None
assert new_samp == fetched, "update != download response"
api_instance.delete_assay_datum(looked_up.assay_datum_id)
except ApiException as error:
self.check_api_exception(api_factory,
"AssayDataApi->create_assay_datum", error)
def test_ds_update(self, api_factory):
api_instance = api_factory.DerivativeSampleApi()
try:
samp = openapi_client.DerivativeSample(None)
samp.attrs = [
openapi_client.Attr(attr_type='oxford', attr_value='1234567')
]
created = api_instance.create_derivative_sample(samp)
looked_up = api_instance.download_derivative_samples_by_attr(
'oxford', '1234567')
looked_up = looked_up.derivative_samples[0]
new_samp = openapi_client.DerivativeSample(None)
updated = api_instance.update_derivative_sample(
looked_up.derivative_sample_id, new_samp)
fetched = api_instance.download_derivative_sample(
looked_up.derivative_sample_id)
assert updated == fetched, "update response != download response"
fetched.derivative_sample_id = None
assert new_samp == fetched, "update != download response"
api_instance.delete_derivative_sample(
looked_up.derivative_sample_id)
except ApiException as error:
self.check_api_exception(
api_factory, "DerivativeSampleApi->create_derivative_sample",
error)
def test_location_study(self, api_factory):
api_instance = api_factory.LocationApi()
study_api = api_factory.StudyApi()
loc = openapi_client.Location(None, 27.46362, 90.49542, 'country',
'Trongsa, Trongsa, Bhutan',
'pv_3_locations.txt', 'BTN')
loc.attrs = [
openapi_client.Attr(attr_type='partner_name',
attr_value='bhutan',
study_name='2001-MD-UP')
]
try:
created = api_instance.create_location(loc)
studies = study_api.download_studies()
found = False
for study in studies.studies:
if study.name == '2001-MD-UP' and study.code == '2001':
found = True
assert found, 'Study does not exist'
api_instance.delete_location(created.location_id)
except ApiException as error:
self.check_api_exception(api_factory,
"LocationApi->create_location", error)
def test_update_duplicate(self, api_factory):
api_instance = api_factory.LocationApi()
try:
loc = self.get_next_location()
loc = openapi_client.Location(None, 27.46362, 90.49542, 'country',
'Trongsa, Trongsa, Bhutan', 'pv_3_locations.txt', 'BTN')
loc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='bhutan', study_name='1234-PV')
]
created = api_instance.create_location(loc)
looked_up_locs = api_instance.download_partner_location(loc.attrs[0].attr_value)
looked_up = looked_up_locs.locations[0]
newloc = openapi_client.Location(None, 28.46362, 91.49542, 'location',
'new_Trongsa, Trongsa, Bhutan', 'new_pv_3_locations.txt', 'IND')
new_created = api_instance.create_location(newloc)
with pytest.raises(ApiException, status=422):
created.location_id = new_created.location_id
updated = api_instance.update_location(new_created.location_id, created)
api_instance.delete_location(looked_up.location_id)
api_instance.delete_location(new_created.location_id)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def test_duplicate_study_name(self, api_factory):
api_instance = api_factory.LocationApi()
try:
loc = self.get_next_location()
loc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='Kobeni', study_name='5002-PF-MR-ANON'),
openapi_client.Attr(attr_type='partner_name', attr_value='location name', study_name='5002')
]
with pytest.raises(ApiException, status=422):
created = api_instance.create_location(loc)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def create_sampling_event_from_values(self, values):
doc = None
doc_accuracy = None
study_id = None
ret = None
idents = []
if 'sample_individual_id' in values:
idents.append(
openapi_client.Attr('individual_id',
values['sample_individual_id'],
self._event_set))
if 'roma_pk_id' in values:
idents.append(
openapi_client.Attr('roma_pk_id', values['roma_pk_id'],
self._event_set))
if 'doc' in values:
if isinstance(values['doc'], datetime.date):
doc = values['doc']
else:
if 'year' in values:
if isinstance(values['year'], datetime.date):
doc = values['year']
values['doc_accuracy'] = 'year'
if 'doc_accuracy' in values:
doc_accuracy = values['doc_accuracy']
if 'study_id' in values:
study_id = values['study_id']
samp = openapi_client.SamplingEvent(None, doc=doc)
if doc_accuracy:
samp.doc_accuracy = doc_accuracy
samp.attrs = idents
#print(values)
#print(samp)
return samp
def create_assay_datum_from_values(self, values):
d_sample = openapi_client.AssayDatum(None)
idents = []
if 'assay_datum_id' in values:
idents.append(
openapi_client.Attr('assay_datum_id', values['assay_datum_id'],
self._event_set))
if 'assay_datum_source' in values:
idents.append(
openapi_client.Attr('assay_datum_source',
values['assay_datum_source'],
self._event_set))
if 'ebi_run_acc' in values:
d_sample.ebi_run_acc = values['ebi_run_acc']
d_sample.attrs = idents
return d_sample
def create_individual_from_values(self, values):
study_id = None
if 'study_id' in values:
study_id = values['study_id']
o_sample = openapi_client.Individual(None)
idents = []
if 'patient_id' in values and values['patient_id']:
idents.append(openapi_client.Attr('patient_id',
str(values['patient_id']),
study_name=study_id,
attr_source=self._event_set))
if 'donor_source_code' in values and values['donor_source_code']:
idents.append(openapi_client.Attr('donor_source_code',
str(values['donor_source_code']),
study_name=study_id,
attr_source=self._event_set))
o_sample.attrs = idents
return o_sample
def create_test_samples(self, api_factory, study_name):
api_instance = api_factory.OriginalSampleApi()
ds_api_instance = api_factory.DerivativeSampleApi()
study_api = api_factory.StudyApi()
samp = openapi_client.OriginalSample(None,
study_name=study_name,
partner_species='PF')
samp.attrs = [
openapi_client.Attr(attr_type='ds_os_attr', attr_value='123456')
]
created = api_instance.create_original_sample(samp)
study_detail = study_api.download_study(study_name)
study_detail.partner_species[0].taxa = [
openapi_client.Taxonomy(taxonomy_id=5833)
]
study_api.update_study(study_name, study_detail)
samp1 = openapi_client.DerivativeSample(None)
samp2 = openapi_client.DerivativeSample(None)
samp1.attrs = [
openapi_client.Attr(attr_type='test1',
attr_value='test1',
attr_source='ds_os_attr')
]
samp2.attrs = [
openapi_client.Attr(attr_type='test2',
attr_value='test2',
attr_source='ds_os_attr')
]
samp1.original_sample_id = created.original_sample_id
samp2.original_sample_id = created.original_sample_id
created1 = ds_api_instance.create_derivative_sample(samp1)
created2 = ds_api_instance.create_derivative_sample(samp2)
return created, created1, created2
def create_original_sample_from_values(self, values):
study_id = None
if 'study_id' in values:
study_id = values['study_id']
o_sample = openapi_client.OriginalSample(None, study_name=study_id)
idents = []
if 'sample_roma_id' in values:
idents.append(openapi_client.Attr ('roma_id', values['sample_roma_id'],
self._event_set))
if 'sample_partner_id' in values and values['sample_partner_id']:
idents.append(openapi_client.Attr ('partner_id', values['sample_partner_id'],
self._event_set))
if 'sample_partner_id_1' in values and values['sample_partner_id_1']:
idents.append(openapi_client.Attr ('partner_id', values['sample_partner_id_1'],
self._event_set))
if 'sample_oxford_id' in values and values['sample_oxford_id']:
idents.append(openapi_client.Attr ('oxford_id', values['sample_oxford_id'],
self._event_set))
if 'sample_alternate_oxford_id' in values and len(values['sample_alternate_oxford_id']) > 0:
idents.append(openapi_client.Attr ('alt_oxford_id',
values['sample_alternate_oxford_id'],
self._event_set))
if 'sample_source_id' in values and values['sample_source_id'] and values['sample_source_type']:
idents.append(openapi_client.Attr (values['sample_source_type'],
values['sample_source_id'],
self._event_set))
if 'sample_source_id1' in values and values['sample_source_id1'] and values['sample_source_type1']:
idents.append(openapi_client.Attr (values['sample_source_type1'],
values['sample_source_id1'],
self._event_set))
if 'sample_source_id2' in values and values['sample_source_id2'] and values['sample_source_type2']:
idents.append(openapi_client.Attr (values['sample_source_type2'],
values['sample_source_id2'],
self._event_set))
if 'days_in_culture' in values:
o_sample.days_in_culture = int(float(values['days_in_culture']))
if 'species' in values and values['species'] and len(values['species']) > 0:
o_sample.partner_species = values['species']
o_sample.attrs = idents
return o_sample
def get_next_individual(self):
indiv = openapi_client.Individual(None)
ident = openapi_client.Attr(attr_type='patient_id',
attr_value=f'Patient{self._individual_number}',
attr_source='TestIndividual',
study_name='6003-PF-MR-ANON')
indiv.attrs = [
ident
]
self._individual_number = self._individual_number + 1
return indiv
def test_ds_update_duplicate(self, api_factory):
api_instance = api_factory.DerivativeSampleApi()
try:
samp = openapi_client.DerivativeSample(None)
samp.attrs = [
openapi_client.Attr(attr_type='oxford',
attr_value='12345678',
attr_source='upd')
]
created = api_instance.create_derivative_sample(samp)
looked_up = api_instance.download_derivative_samples_by_attr(
'oxford', '12345678')
looked_up = looked_up.derivative_samples[0]
new_samp = openapi_client.DerivativeSample(None)
new_samp.attrs = [
openapi_client.Attr(attr_type='oxford',
attr_value='123456789',
attr_source='upd')
]
new_created = api_instance.create_derivative_sample(new_samp)
with pytest.raises(ApiException, status=422):
updated = api_instance.update_derivative_sample(
looked_up.derivative_sample_id, new_samp)
api_instance.delete_derivative_sample(
looked_up.derivative_sample_id)
api_instance.delete_derivative_sample(
new_created.derivative_sample_id)
except ApiException as error:
self.check_api_exception(
api_factory, "DerivativeSampleApi->create_derivative_sample",
error)
def test_create_duplicate_ident(self, api_factory):
api_instance = api_factory.LocationApi()
try:
loc = self.get_next_location()
ident = openapi_client.Attr(attr_type='partner_name', attr_value='Kobeni', study_name='5003-PF-MR-ANON')
loc.attrs = [
ident,
ident
]
with pytest.raises(ApiException, status=422):
created1 = api_instance.create_location(loc)
with pytest.raises(ApiException, status=404):
looked_up = api_instance.download_gps_location(loc.latitude, loc.longitude)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def test_gps_lookup(self, api_factory):
api_instance = api_factory.LocationApi()
try:
loc = self.get_next_location()
loc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='bhutan', study_name='1234-PV')
]
created = api_instance.create_location(loc)
looked_up = api_instance.download_gps_location(loc.latitude, loc.longitude)
fetched = looked_up.locations[0]
assert created == fetched, "create response != download response"
fetched.location_id = None
assert loc == fetched, "upload != download response"
api_instance.delete_location(created.location_id)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def test_get_location_attrs(self, api_factory):
metadata_api_instance = api_factory.MetadataApi()
api_instance = api_factory.LocationApi()
try:
loc = self.get_next_location()
loc = openapi_client.Location(None, 27.46362, 90.49542, 'country',
'Trongsa, Trongsa, Bhutan', 'pv_3_locations.txt', 'BTN')
loc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='bhutan', study_name='1234-PV')
]
created = api_instance.create_location(loc)
idents = metadata_api_instance.get_location_attr_types()
assert 'partner_name' in idents
api_instance.delete_location(created.location_id)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def test_ad_duplicate_key(self, api_factory):
api_instance = api_factory.AssayDataApi()
try:
samp = openapi_client.AssayDatum(None)
samp.attrs = [
openapi_client.Attr(attr_type='oxford',
attr_value='1234',
attr_source='same')
]
created = api_instance.create_assay_datum(samp)
with pytest.raises(ApiException, status=422):
created = api_instance.create_assay_datum(samp)
api_instance.delete_assay_datum(created.assay_datum_id)
except ApiException as error:
self.check_api_exception(api_factory,
"AssayDataApi->create_assay_datum", error)
def test_ds_attr_lookup_encode(self, api_factory):
api_instance = api_factory.DerivativeSampleApi()
try:
test_id = 'MDG/DK_0005'
samp = openapi_client.DerivativeSample(None)
samp.attrs = [
openapi_client.Attr(attr_type='partner_id',
attr_value=test_id,
attr_source='encode')
]
created = api_instance.create_derivative_sample(samp)
fetched = api_instance.download_derivative_sample(
created.derivative_sample_id)
assert created == fetched, "create response != download response"
fetched.derivative_sample_id = None
assert samp == fetched, "upload != download response"
results = api_instance.download_derivative_samples_by_attr(
'partner_id', urllib.parse.quote_plus(test_id))
looked_up = results.derivative_samples[0]
fetched = api_instance.download_derivative_sample(
looked_up.derivative_sample_id)
assert created == fetched, "create response != download response"
fetched.derivative_sample_id = None
assert samp == fetched, "upload != download response"
api_instance.delete_derivative_sample(created.derivative_sample_id)
except ApiException as error:
self.check_api_exception(
api_factory, "DerivativeSampleApi->create_derivative_sample",
error)
def test_gps_lookup_negative(self, api_factory):
api_instance = api_factory.LocationApi()
try:
loc = openapi_client.Location(None, 15.82083, -9.4145, None, None, None, None)
loc.attrs = [
openapi_client.Attr(attr_type='partner_name', attr_value='Kobeni', study_name='5002-PF-MR-ANON')
]
created = api_instance.create_location(loc)
looked_up = api_instance.download_gps_location(15.82083, -9.4145)
fetched = looked_up.locations[0]
assert created == fetched, "create response != download response"
fetched.location_id = None
assert loc == fetched, "upload != download response"
api_instance.delete_location(created.location_id)
except ApiException as error:
self.check_api_exception(api_factory, "LocationApi->create_location", error)
def test_ds_duplicate_key(self, api_factory):
api_instance = api_factory.DerivativeSampleApi()
try:
samp = openapi_client.DerivativeSample(None)
samp.attrs = [
openapi_client.Attr(attr_type='oxford',
attr_value='1234',
attr_source='same')
]
created = api_instance.create_derivative_sample(samp)
with pytest.raises(ApiException, status=422):
created = api_instance.create_derivative_sample(samp)
api_instance.delete_derivative_sample(created.derivative_sample_id)
except ApiException as error:
self.check_api_exception(
api_factory, "DerivativeSampleApi->create_derivative_sample",
error)
def test_ad_attr_lookup_encode(self, api_factory):
api_instance = api_factory.AssayDataApi()
try:
test_id = 'MDG/DK_0005'
samp = openapi_client.AssayDatum(None)
samp.attrs = [
openapi_client.Attr(attr_type='partner_id',
attr_value=test_id,
attr_source='encode')
]
created = api_instance.create_assay_datum(samp)
fetched = api_instance.download_assay_datum(created.assay_datum_id)
assert created == fetched, "create response != download response"
fetched.assay_datum_id = None
assert samp == fetched, "upload != download response"
results = api_instance.download_assay_data_by_attr(
'partner_id', urllib.parse.quote_plus(test_id))
looked_up = results.assay_data[0]
fetched = api_instance.download_assay_datum(
looked_up.assay_datum_id)
assert created == fetched, "create response != download response"
fetched.assay_datum_id = None
assert samp == fetched, "upload != download response"
api_instance.delete_assay_datum(created.assay_datum_id)
except ApiException as error:
self.check_api_exception(api_factory,
"AssayDataApi->create_assay_datum", error)
def test_ad_attr_lookup(self, api_factory):
api_instance = api_factory.AssayDataApi()
ds_api_instance = api_factory.DerivativeSampleApi()
try:
samp1 = openapi_client.DerivativeSample(None)
created1 = ds_api_instance.create_derivative_sample(samp1)
samp = openapi_client.AssayDatum(None)
samp.attrs = [
openapi_client.Attr(attr_type='oxford', attr_value='123456')
]
samp.derivative_sample_id = created1.derivative_sample_id
created = api_instance.create_assay_datum(samp)
results = api_instance.download_assay_data_by_attr(
'oxford', '123456')
looked_up = results.assay_data[0]
fetched = api_instance.download_assay_datum(
looked_up.assay_datum_id)
assert created == fetched, "create response != download response"
fetched.assay_datum_id = None
assert samp == fetched, "upload != download response"
api_instance.delete_assay_datum(created.assay_datum_id)
ds_api_instance.delete_derivative_sample(
created1.derivative_sample_id)
except ApiException as error:
self.check_api_exception(api_factory,
"AssayDataApi->create_assay_datum", error)
