def test404sReturnJson(self):
paths = [
'/doesNotExist',
'/reads/sea',
'/variantsets/id/doesNotExist',
]
for path in paths:
response = self.app.get(path)
protocol.fromJson(response.get_data(), protocol.GAException)
self.assertEqual(404, response.status_code)
def test404sReturnJson(self):
paths = [
'/doesNotExist',
'/reads/sea',
'/variantsets/id/doesNotExist',
]
for path in paths:
response = self.app.get(path)
protocol.fromJson(
response.get_data(), protocol.GAException)
self.assertEqual(404, response.status_code)
def test_search_datasets(self):
response = self.client.post('/datasets/search', data='{}')
response_proto = protocol.fromJson(response.get_data(),
protocol.SearchDatasetsResponse)
self.assertIsNotNone(response_proto, "Something should be returned")
self.assertEqual(response.status_code, 200, "A known good endpoint "
"should return success")
self.assertGreater(len(response_proto.datasets), 0,
"Some datasets should be returned.")
response = self.client.post('/datasets/search', data='{"pageSize": 2}')
response_proto = protocol.fromJson(response.get_data(),
protocol.SearchDatasetsResponse)
self.assertEqual(len(response_proto.datasets), 2)
def populateFromRow(self, readGroupSetRecord):
"""
Populates the instance variables of this ReadGroupSet from the
specified database row.
"""
self._dataUrl = readGroupSetRecord.dataurl
self._indexFile = readGroupSetRecord.indexfile
self._programs = []
for jsonDict in json.loads(readGroupSetRecord.programs):
program = protocol.fromJson(json.dumps(jsonDict), protocol.Program)
self._programs.append(program)
stats = protocol.fromJson(readGroupSetRecord.stats, protocol.ReadStats)
self._numAlignedReads = stats.aligned_read_count
self._numUnalignedReads = stats.unaligned_read_count
def populateFromRow(self, readGroupSetRecord):
"""
Populates the instance variables of this ReadGroupSet from the
specified database row.
"""
self._dataUrl = readGroupSetRecord.dataurl
self._indexFile = readGroupSetRecord.indexfile
self._programs = []
for jsonDict in json.loads(readGroupSetRecord.programs):
program = protocol.fromJson(json.dumps(jsonDict),
protocol.Program)
self._programs.append(program)
stats = protocol.fromJson(readGroupSetRecord.stats, protocol.ReadStats)
self._numAlignedReads = stats.aligned_read_count
self._numUnalignedReads = stats.unaligned_read_count
def test_search_read_group_sets(self):
response = self.client.post('/readgroupsets/search', data='{}')
response_proto = protocol.fromJson(
response.get_data(), protocol.SearchReadGroupSetsResponse)
self.assertIsNotNone(response_proto, "Something should be returned")
self.assertEqual(response.status_code, 200, "A known good endpoint "
"should return success")
self.assertGreater(len(response_proto.read_group_sets), 0,
"Some read group sets should be returned.")
response = self.client.post('/readgroupsets/search',
data='{"read_group_sets": 356464}')
response_proto = protocol.fromJson(
response.get_data(), protocol.SearchReadGroupSetsResponse)
self.assertEqual(len(response_proto.read_group_sets), 356464)
def sendCallSetsSearch(self):
response = self.sendVariantSetsSearch()
variantSets = protocol.fromJson(
response.data, protocol.SearchVariantSetsResponse).variant_sets
request = protocol.SearchCallSetsRequest()
request.variant_set_id = variantSets[0].id
return self.sendPostRequest('/callsets/search', request)
def test_search_reads(self):
run_accession = 'SRR2856889' # paired
# acc = 'SRR1482462' # unpaired
reference_name = 'chr1'
start = 9000000
end = 9100000
request = protocol.SearchReadsRequest()
request.read_group_ids.extend([run_accession])
request.reference_id = reference_name
request.start = start
request.end = end
reads_list = ncbi.search_reads(request)
response = self.client.post('/reads/search',
data=protocol.toJson(request))
response_proto = protocol.fromJson(response.get_data(),
protocol.SearchReadsResponse)
self.assertIsNotNone(response_proto, "Something should be returned")
self.assertEqual(response.status_code, 200, "A known good endpoint "
"should return success")
i = 0
for ga_alignment in response_proto.alignments:
self.assertEqual(reads_list[i], ga_alignment)
i += 1
self.assertGreater(len(response_proto.alignments), 0,
"Some alignments should be returned.")
def search_reads_route():
search_request = protocol.SearchReadsRequest
try:
deserialized_request = protocol.fromJson(request.get_data(),
search_request)
except Exception, e:
print str(e)
def runSearchRequest(
self, requestStr, requestClass, responseClass, objectGenerator):
"""
Runs the specified request. The request is a string containing
a JSON representation of an instance of the specified requestClass.
We return a string representation of an instance of the specified
responseClass in JSON format. Objects are filled into the page list
using the specified object generator, which must return
(object, nextPageToken) pairs, and be able to resume iteration from
any point using the nextPageToken attribute of the request object.
"""
self.startProfile()
try:
request = protocol.fromJson(requestStr, requestClass)
except protocol.json_format.ParseError:
raise exceptions.InvalidJsonException(requestStr)
# TODO How do we detect when the page size is not set?
if not request.page_size:
request.page_size = self._defaultPageSize
if request.page_size < 0:
raise exceptions.BadPageSizeException(request.page_size)
responseBuilder = response_builder.SearchResponseBuilder(
responseClass, request.page_size, self._maxResponseLength)
nextPageToken = None
for obj, nextPageToken in objectGenerator(request):
responseBuilder.addValue(obj)
if responseBuilder.isFull():
break
responseBuilder.setNextPageToken(nextPageToken)
responseString = responseBuilder.getSerializedResponse()
self.endProfile()
return responseString
def runSearchRequest(
self, requestStr, requestClass, responseClass, objectGenerator):
"""
Runs the specified request. The request is a string containing
a JSON representation of an instance of the specified requestClass.
We return a string representation of an instance of the specified
responseClass in JSON format. Objects are filled into the page list
using the specified object generator, which must return
(object, nextPageToken) pairs, and be able to resume iteration from
any point using the nextPageToken attribute of the request object.
"""
self.startProfile()
try:
request = protocol.fromJson(requestStr, requestClass)
except protocol.json_format.ParseError:
raise exceptions.InvalidJsonException(requestStr)
# TODO How do we detect when the page size is not set?
if not request.page_size:
request.page_size = self._defaultPageSize
if request.page_size < 0:
raise exceptions.BadPageSizeException(request.page_size)
responseBuilder = response_builder.SearchResponseBuilder(
responseClass, request.page_size, self._maxResponseLength)
nextPageToken = None
for obj, nextPageToken in objectGenerator(request):
responseBuilder.addValue(obj)
if responseBuilder.isFull():
break
responseBuilder.setNextPageToken(nextPageToken)
responseString = responseBuilder.getSerializedResponse()
self.endProfile()
return responseString
def populateFromJson(self, jsonString):
try:
parsed = protocol.fromJson(jsonString, protocol.Experiment)
except:
raise exceptions.InvalidJsonException(jsonString)
if parsed.message_create_time != "":
self._created = parsed.message_create_time
if parsed.message_update_time != "":
self._updated = parsed.message_update_time
self._run_time = parsed.run_time
self._description = parsed.description
self._molecule = parsed.molecule
self._strategy = parsed.strategy
self._selection = parsed.selection
self._library = parsed.library
self._library_layout = parsed.library_layout
self._instrument_model = parsed.instrument_model
self._instrument_data_file = parsed.instrument_data_file
self._sequencing_center = parsed.sequencing_center
self._platform_unit = parsed.platform_unit
attributes = {}
for key in parsed.attributes.attr:
attributes[key] = {
"values": protocol.toJsonDict(parsed.attributes.attr[key])
}
self.setAttributes(attributes)
return self
def _deserialize_response(self, json_response_string,
protocol_response_class):
self._protocol_bytes_received += len(json_response_string)
self._logger.debug("response:{}".format(json_response_string))
if not json_response_string:
raise exceptions.EmptyResponseException()
return protocol.fromJson(json_response_string, protocol_response_class)
def testNextPageToken(self):
responseClass = protocol.SearchVariantsResponse
builder = response_builder.SearchResponseBuilder(
responseClass, 100, 2 ** 32)
# If not set, pageToken should be empty string
self.assertIsNone(builder.getNextPageToken())
instance = protocol.fromJson(builder.getSerializedResponse(),
responseClass)
self.assertEqual(instance.next_page_token, "")
# page tokens can be any string.
for nextPageToken in ["", "string"]:
builder.setNextPageToken(nextPageToken)
self.assertEqual(nextPageToken, builder.getNextPageToken())
instance = protocol.fromJson(builder.getSerializedResponse(),
responseClass)
self.assertEqual(nextPageToken, instance.next_page_token)
def sendCallSetsSearch(self):
response = self.sendVariantSetsSearch()
variantSets = protocol.fromJson(
response.data, protocol.SearchVariantSetsResponse).variant_sets
request = protocol.SearchCallSetsRequest()
request.variant_set_id = variantSets[0].id
return self.sendPostRequest('/callsets/search', request)
def testToJsonAndFromJson(self):
classes = protocol.getProtocolClasses()
for clazz in classes:
obj = clazz()
jsonStr = protocol.toJson(obj)
obj2 = protocol.fromJson(jsonStr, clazz)
self.assertTrue(obj, obj2)
def testCompoundFeatureSearch(self):
datasetName, featureSet = self.getCGDDataSetFeatureSet()
featureId = \
"http://cancer.sanger.ac.uk/cosmic/mutation/overview?id=736"
obfuscated = self.getObfuscatedFeatureCompoundId(
datasetName, featureSet.name, featureId)
request = protocol.GetFeatureRequest
request.feature_id = obfuscated
response = self.sendGetRequest('/features/{}'.format(obfuscated))
feature = protocol.fromJson(response.data, protocol.Feature)
self.assertIsNotNone(feature)
featureId = feature.id
request = protocol.SearchGenotypePhenotypeRequest()
request.phenotype_association_set_id = \
self.getPhenotypeAssociationSetId()
request.feature_ids.append(featureId)
response = self.sendSearchRequest(
'/featurephenotypeassociations/search',
request,
protocol.SearchGenotypePhenotypeResponse)
self.assertEqual(1, len(response.associations))
self.assertEqual(1, len(response.associations[0].feature_ids))
def testToJsonAndFromJson(self):
classes = protocol.getProtocolClasses()
for clazz in classes:
obj = clazz()
jsonStr = protocol.toJson(obj)
obj2 = protocol.fromJson(jsonStr, clazz)
self.assertTrue(obj, obj2)
def testNextPageToken(self):
responseClass = protocol.SearchVariantsResponse
builder = response_builder.SearchResponseBuilder(
responseClass, 100, 2**32)
# If not set, pageToken should be empty string
self.assertIsNone(builder.getNextPageToken())
instance = protocol.fromJson(builder.getSerializedResponse(),
responseClass)
self.assertEqual(instance.next_page_token, "")
# page tokens can be any string.
for nextPageToken in ["", "string"]:
builder.setNextPageToken(nextPageToken)
self.assertEqual(nextPageToken, builder.getNextPageToken())
instance = protocol.fromJson(builder.getSerializedResponse(),
responseClass)
self.assertEqual(nextPageToken, instance.next_page_token)
def testReadsSearch(self):
response = self.sendReadsSearch(readGroupIds=[self.readGroupId],
referenceId=self.referenceId)
self.assertEqual(200, response.status_code)
responseData = protocol.fromJson(response.data,
protocol.SearchReadsResponse)
self.assertEqual(len(responseData.alignments), 2)
self.assertEqual(responseData.alignments[0].id, self.readAlignmentId)
def searchObjectTest(
self, responseMethod, responseClass, attributeName, objectId):
response = responseMethod()
self.assertEqual(200, response.status_code)
responseData = protocol.fromJson(response.data, responseClass)
responseList = getattr(responseData, attributeName)
objectList = list(responseList)
self.assertEqual(objectId, objectList[0].id)
def searchObjectTest(self, responseMethod, responseClass, attributeName,
objectId):
response = responseMethod()
self.assertEqual(200, response.status_code)
responseData = protocol.fromJson(response.data, responseClass)
responseList = getattr(responseData, attributeName)
objectList = list(responseList)
self.assertEqual(objectId, objectList[0].id)
def test_schemas_deserialization(self):
# Mock search datasets request
request = '{"pageSize": 3, "pageToken": "text"}'
# We pass the class, not an instance of the class to `fromJson`
request_schema = protocol.SearchDatasetsRequest
deserialized_request = protocol.fromJson(request, request_schema)
self.assertEqual(
3, deserialized_request.page_size,
"The deserialized version should also have 3 for page_size.")
def testSimplePost(self):
path = "/datasets/search"
response = protocol.fromJson(self.app.post(
path, headers={}).get_data(), protocol.SearchDatasetsResponse)
self.assertIsNotNone(
response.datasets,
"When an empty JSON document "
"without a mimetype is sent we can still"
"get datasets.")
def populateFromRow(self, readGroupRecord):
"""
Populate the instance variables using the specified DB row.
"""
self._sampleName = readGroupRecord.samplename
self._biosampleId = readGroupRecord.biosampleid
self._description = readGroupRecord.description
self._predictedInsertSize = readGroupRecord.predictedinsertsize
stats = protocol.fromJson(readGroupRecord.stats, protocol.ReadStats)
self._numAlignedReads = stats.aligned_read_count
self._numUnalignedReads = stats.unaligned_read_count
experiment = protocol.fromJson(readGroupRecord.experiment,
protocol.Experiment)
self._instrumentModel = experiment.instrument_model
self._sequencingCenter = experiment.sequencing_center
self._experimentDescription = experiment.description
self._library = experiment.library
self._platformUnit = experiment.platform_unit
self._runTime = experiment.run_time
def testPhenotypeAssociationSetsSearch(self):
response = self.sendPhenotypeAssociationSetsSearch()
responseData = protocol.fromJson(
response.data, protocol.SearchPhenotypeAssociationSetsResponse)
pasets = list(responseData.phenotype_association_sets)
foundPASet = False
for paset in pasets:
if self.phenotypeAssociationSetId == paset.id:
foundPASet = True
self.assertTrue(foundPASet)
def testPhenotypeAssociationSetsSearch(self):
response = self.sendPhenotypeAssociationSetsSearch()
responseData = protocol.fromJson(
response.data, protocol.SearchPhenotypeAssociationSetsResponse)
pasets = list(responseData.phenotype_association_sets)
foundPASet = False
for paset in pasets:
if self.phenotypeAssociationSetId == paset.id:
foundPASet = True
self.assertTrue(foundPASet)
def testReadsSearch(self):
response = self.sendReadsSearch(readGroupIds=[self.readGroupId],
referenceId=self.referenceId)
self.assertEqual(200, response.status_code)
responseData = protocol.fromJson(
response.data, protocol.SearchReadsResponse)
self.assertEqual(len(responseData.alignments), 2)
self.assertEqual(
responseData.alignments[0].id,
self.readAlignmentId)
def toProtocolElement(self):
species = None
sex = None
if self.getSpecies():
species = protocol.fromJson(json.dumps(self.getSpecies()),
protocol.OntologyTerm)
if self.getSex():
sex = protocol.fromJson(json.dumps(self.getSex()),
protocol.OntologyTerm)
gaIndividual = protocol.Individual(dataset_id=self._datasetId,
created=self.getCreated(),
updated=self.getUpdated(),
description=self.getDescription(),
id=self.getId(),
name=self.getName(),
species=species,
sex=sex)
self.serializeAttributes(gaIndividual)
return gaIndividual
def sendVariantsSearch(self):
response = self.sendVariantSetsSearch()
variantSets = protocol.fromJson(
response.data, protocol.SearchVariantSetsResponse).variant_sets
request = protocol.SearchVariantsRequest()
request.variant_set_id = variantSets[0].id
request.reference_name = "1"
request.start = 0
request.end = 1
return self.sendPostRequest('/variants/search', request)
def sendVariantsSearch(self):
response = self.sendVariantSetsSearch()
variantSets = protocol.fromJson(
response.data, protocol.SearchVariantSetsResponse).variant_sets
request = protocol.SearchVariantsRequest()
request.variant_set_id = variantSets[0].id
request.reference_name = "1"
request.start = 0
request.end = 1
return self.sendPostRequest('/variants/search', request)
def populateFromRow(self, readGroupRecord):
"""
Populate the instance variables using the specified DB row.
"""
self._sampleName = readGroupRecord.samplename
self._biosampleId = readGroupRecord.biosampleid
self._description = readGroupRecord.description
self._predictedInsertSize = readGroupRecord.predictedinsertsize
stats = protocol.fromJson(readGroupRecord.stats, protocol.ReadStats)
self._numAlignedReads = stats.aligned_read_count
self._numUnalignedReads = stats.unaligned_read_count
experiment = protocol.fromJson(
readGroupRecord.experiment, protocol.Experiment)
self._instrumentModel = experiment.instrument_model
self._sequencingCenter = experiment.sequencing_center
self._experimentDescription = experiment.description
self._library = experiment.library
self._platformUnit = experiment.platform_unit
self._runTime = experiment.run_time
def sendSearchRequest(self, path, request, responseClass):
"""
Sends the specified protocol request instance as JSON, and
parses the result into an instance of the specified response.
"""
response = self.sendJsonPostRequest(path, protocol.toJson(request))
self.assertEqual(200, response.status_code)
responseData = protocol.fromJson(response.data, responseClass)
self.assertTrue(
protocol.validate(protocol.toJson(responseData), responseClass))
return responseData
def toProtocolElement(self):
species = None
sex = None
if self.getSpecies():
species = protocol.fromJson(
json.dumps(self.getSpecies()), protocol.OntologyTerm)
if self.getSex():
sex = protocol.fromJson(
json.dumps(self.getSex()), protocol.OntologyTerm)
gaIndividual = protocol.Individual(
dataset_id=self._datasetId,
created=self.getCreated(),
updated=self.getUpdated(),
description=self.getDescription(),
id=self.getId(),
name=self.getName(),
species=species,
sex=sex)
self.serializeAttributes(gaIndividual)
return gaIndividual
def sendSearchRequest(self, path, request, responseClass):
"""
Sends the specified protocol request instance as JSON, and
parses the result into an instance of the specified response.
"""
response = self.sendJsonPostRequest(path, protocol.toJson(request))
self.assertEqual(200, response.status_code)
responseData = protocol.fromJson(response.data, responseClass)
self.assertTrue(
protocol.validate(protocol.toJson(responseData), responseClass))
return responseData
def verifySearchRouting(self, path, getDefined=False):
"""
Verifies that the specified path has the correct routing for a
search command. If getDefined is False we check to see if it
returns the correct status code.
"""
if not getDefined:
getResponse = self.app.get(path)
protocol.fromJson(
getResponse.get_data(), protocol.GAException)
self.assertEqual(405, getResponse.status_code)
# Malformed requests should return 400
for badJson in ["JSON", "<xml/>", "{]"]:
badResponse = self.app.post(
path, data=badJson,
headers={'Content-type': 'application/json'})
self.assertEqual(400, badResponse.status_code)
# OPTIONS should return success
self.assertEqual(200, self.app.options(path).status_code)
def testGetVariantSet(self):
response = self.sendVariantSetsSearch()
responseData = protocol.fromJson(
response.data, protocol.SearchVariantSetsResponse)
variantSetId = responseData.variant_sets[0].id
response = self.sendGetVariantSet(variantSetId)
self.assertEqual(200, response.status_code)
invalidId = datamodel.VariantSetCompoundId.getInvalidIdString()
obfuscated = datamodel.CompoundId.obfuscate(invalidId)
compoundId = datamodel.VariantSetCompoundId.parse(obfuscated)
response = self.sendGetVariantSet(str(compoundId))
self.assertEqual(404, response.status_code)
def toProtocolElement(self):
disease = None
if self.getDisease():
disease = protocol.fromJson(
json.dumps(self.getDisease()), protocol.OntologyTerm)
individualAgeAtCollection = None
if self.getIndividualAgeAtCollection():
individualAgeAtCollection = protocol.fromJson(
json.dumps(self.getIndividualAgeAtCollection()), protocol.Age)
biosample = protocol.Biosample(
dataset_id=self._datasetId,
created=self.getCreated(),
updated=self.getUpdated(),
description=self.getDescription(),
id=self.getId(),
individual_id=self.getIndividualId(),
name=self.getName(),
disease=disease,
individual_age_at_collection=individualAgeAtCollection)
self.serializeAttributes(biosample)
return biosample
def setSpeciesFromJson(self, speciesJson):
"""
Sets the species, an OntologyTerm, to the specified value, given as
a JSON string.
See the documentation for details of this field.
"""
try:
parsed = protocol.fromJson(speciesJson, protocol.OntologyTerm)
except:
raise exceptions.InvalidJsonException(speciesJson)
self._species = protocol.toJsonDict(parsed)
def setSpeciesFromJson(self, speciesJson):
"""
Sets the species, an OntologyTerm, to the specified value, given as
a JSON string.
See the documentation for details of this field.
"""
try:
parsed = protocol.fromJson(speciesJson, protocol.OntologyTerm)
except:
raise exceptions.InvalidJsonException(speciesJson)
self._species = protocol.toJsonDict(parsed)
def toProtocolElement(self):
disease = None
if self.getDisease():
disease = protocol.fromJson(json.dumps(self.getDisease()),
protocol.OntologyTerm)
individualAgeAtCollection = None
if self.getIndividualAgeAtCollection():
individualAgeAtCollection = protocol.fromJson(
json.dumps(self.getIndividualAgeAtCollection()), protocol.Age)
biosample = protocol.Biosample(
dataset_id=self._datasetId,
created=self.getCreated(),
updated=self.getUpdated(),
description=self.getDescription(),
id=self.getId(),
individual_id=self.getIndividualId(),
name=self.getName(),
disease=disease,
individual_age_at_collection=individualAgeAtCollection)
self.serializeAttributes(biosample)
return biosample
def testGetVariantSet(self):
response = self.sendVariantSetsSearch()
responseData = protocol.fromJson(response.data,
protocol.SearchVariantSetsResponse)
variantSetId = responseData.variant_sets[0].id
response = self.sendGetVariantSet(variantSetId)
self.assertEqual(200, response.status_code)
invalidId = datamodel.VariantSetCompoundId.getInvalidIdString()
obfuscated = datamodel.CompoundId.obfuscate(invalidId)
compoundId = datamodel.VariantSetCompoundId.parse(obfuscated)
response = self.sendGetVariantSet(str(compoundId))
self.assertEqual(404, response.status_code)
def runAddAnnouncement(self, flaskrequest):
"""
Takes a flask request from the frontend and attempts to parse
into an AnnouncePeerRequest. If successful, it will log the
announcement to the `announcement` table with some other metadata
gathered from the request.
"""
announcement = {}
# We want to parse the request ourselves to collect a little more
# data about it.
try:
requestData = protocol.fromJson(
flaskrequest.get_data(), protocol.AnnouncePeerRequest)
announcement['hostname'] = flaskrequest.host_url
announcement['remote_addr'] = flaskrequest.remote_addr
announcement['user_agent'] = flaskrequest.headers.get('User-Agent')
except AttributeError:
# Sometimes in testing we will send protocol requests instead
# of flask requests and so the hostname and user agent won't
# be present.
try:
requestData = protocol.fromJson(
flaskrequest, protocol.AnnouncePeerRequest)
except Exception as e:
raise exceptions.InvalidJsonException(e)
except Exception as e:
raise exceptions.InvalidJsonException(e)
# Validate the url before accepting the announcement
peer = datamodel.peers.Peer(requestData.peer.url)
peer.setAttributesJson(protocol.toJson(
requestData.peer.attributes))
announcement['url'] = peer.getUrl()
announcement['attributes'] = peer.getAttributes()
try:
self.getDataRepository().insertAnnouncement(announcement)
except:
raise exceptions.BadRequestException(announcement['url'])
return protocol.toJson(
protocol.AnnouncePeerResponse(success=True))
def runAddAnnouncement(self, flaskrequest):
"""
Takes a flask request from the frontend and attempts to parse
into an AnnouncePeerRequest. If successful, it will log the
announcement to the `announcement` table with some other metadata
gathered from the request.
"""
announcement = {}
# We want to parse the request ourselves to collect a little more
# data about it.
try:
requestData = protocol.fromJson(
flaskrequest.get_data(), protocol.AnnouncePeerRequest)
announcement['hostname'] = flaskrequest.host_url
announcement['remote_addr'] = flaskrequest.remote_addr
announcement['user_agent'] = flaskrequest.headers.get('User-Agent')
except AttributeError:
# Sometimes in testing we will send protocol requests instead
# of flask requests and so the hostname and user agent won't
# be present.
try:
requestData = protocol.fromJson(
flaskrequest, protocol.AnnouncePeerRequest)
except Exception as e:
raise exceptions.InvalidJsonException(e)
except Exception as e:
raise exceptions.InvalidJsonException(e)
# Validate the url before accepting the announcement
peer = datamodel.peers.Peer(requestData.peer.url)
peer.setAttributesJson(protocol.toJson(
requestData.peer.attributes))
announcement['url'] = peer.getUrl()
announcement['attributes'] = peer.getAttributes()
try:
self.getDataRepository().insertAnnouncement(announcement)
except:
raise exceptions.BadRequestException(announcement['url'])
return protocol.toJson(
protocol.AnnouncePeerResponse(success=True))
def testPageSizeExactFill(self):
responseClass = protocol.SearchVariantsResponse
valueClass = protocol.Variant
for pageSize in range(1, 10):
builder = response_builder.SearchResponseBuilder(
responseClass, pageSize, 2**32)
self.assertEqual(builder.getPageSize(), pageSize)
while not builder.isFull():
builder.addValue(valueClass())
instance = protocol.fromJson(builder.getSerializedResponse(),
responseClass)
valueList = getattr(instance, getValueListName(responseClass))
self.assertEqual(len(valueList), pageSize)
def assertRawRequestRaises(self, exceptionClass, url, requestString):
"""
Verifies that the specified request string returns a protocol
exception corresponding to the specified class when applied to
all POST endpoints.
"""
response = self.app.post(url,
headers={'Content-type': 'application/json'},
data=requestString)
self.assertEqual(response.status_code, exceptionClass.httpStatus)
error = protocol.fromJson(response.data, protocol.GAException)
self.assertEqual(error.error_code, exceptionClass.getErrorCode())
self.assertGreater(len(error.message), 0)
def testPageSizeExactFill(self):
responseClass = protocol.SearchVariantsResponse
valueClass = protocol.Variant
for pageSize in range(1, 10):
builder = response_builder.SearchResponseBuilder(
responseClass, pageSize, 2 ** 32)
self.assertEqual(builder.getPageSize(), pageSize)
while not builder.isFull():
builder.addValue(valueClass())
instance = protocol.fromJson(builder.getSerializedResponse(),
responseClass)
valueList = getattr(instance, getValueListName(responseClass))
self.assertEqual(len(valueList), pageSize)
def assertRawRequestRaises(self, exceptionClass, url, requestString):
"""
Verifies that the specified request string returns a protocol
exception corresponding to the specified class when applied to
all POST endpoints.
"""
response = self.app.post(
url, headers={'Content-type': 'application/json'},
data=requestString)
self.assertEqual(response.status_code, exceptionClass.httpStatus)
error = protocol.fromJson(response.data, protocol.GAException)
self.assertEqual(
error.error_code, exceptionClass.getErrorCode())
self.assertGreater(len(error.message), 0)
def testGetDataset(self):
# Test OK: ID found
response = self.sendDatasetsSearch()
responseData = protocol.fromJson(
response.data, protocol.SearchDatasetsResponse)
datasetId = responseData.datasets[0].id
response = self.sendGetDataset(datasetId)
self.assertEqual(200, response.status_code)
# Test Error: 404, ID not found
invalidId = datamodel.DatasetCompoundId.getInvalidIdString()
obfuscated = datamodel.CompoundId.obfuscate(invalidId)
compoundId = datamodel.DatasetCompoundId.parse(obfuscated)
response = self.sendGetDataset(str(compoundId))
self.assertEqual(404, response.status_code)
def getPhenotypeAssociationSetId(self):
"""
Gets the dataset phenotype association set ID
"""
request = protocol.SearchDatasetsRequest()
response = self.sendSearchRequest("datasets/search", request,
protocol.SearchDatasetsResponse)
datasetId = response.datasets[0].id
request = protocol.SearchPhenotypeAssociationSetsRequest()
request.dataset_id = datasetId
response = self.sendPostRequest("phenotypeassociationsets/search",
request)
response = protocol.fromJson(
response.data, protocol.SearchPhenotypeAssociationSetsResponse)
return response.phenotype_association_sets[0].id
def testGetDataset(self):
# Test OK: ID found
response = self.sendDatasetsSearch()
responseData = protocol.fromJson(response.data,
protocol.SearchDatasetsResponse)
datasetId = responseData.datasets[0].id
response = self.sendGetDataset(datasetId)
self.assertEqual(200, response.status_code)
# Test Error: 404, ID not found
invalidId = datamodel.DatasetCompoundId.getInvalidIdString()
obfuscated = datamodel.CompoundId.obfuscate(invalidId)
compoundId = datamodel.DatasetCompoundId.parse(obfuscated)
response = self.sendGetDataset(str(compoundId))
self.assertEqual(404, response.status_code)
def verifySearchRouting(self, path, getDefined=False):
"""
Verifies that the specified path has the correct routing for a
search command. If getDefined is False we check to see if it
returns the correct status code.
"""
response = self.app.post(path)
protocol.fromJson(response.get_data(), protocol.GAException)
self.assertEqual(415, response.status_code)
if not getDefined:
getResponse = self.app.get(path)
protocol.fromJson(getResponse.get_data(), protocol.GAException)
self.assertEqual(405, getResponse.status_code)
# Malformed requests should return 400
for badJson in ["", None, "JSON", "<xml/>", "{]"]:
badResponse = self.app.post(
path,
data=badJson,
headers={'Content-type': 'application/json'})
self.assertEqual(400, badResponse.status_code)
# OPTIONS should return success
self.assertEqual(200, self.app.options(path).status_code)
def testIntegrity(self):
# Verifies that the values we put in are exactly what we get
# back across all subclasses of SearchResponse
for class_ in [responseClass for _, _, responseClass in
protocol.postMethods]:
instance = class_()
valueList = getattr(instance, getValueListName(class_))
valueList.add()
builder = response_builder.SearchResponseBuilder(
class_, len(valueList), 2 ** 32)
for value in valueList:
builder.addValue(value)
builder.setNextPageToken(instance.next_page_token)
otherInstance = protocol.fromJson(
builder.getSerializedResponse(), class_)
self.assertEqual(instance, otherInstance)
def testRoundTripDataset(self):
id_ = "id"
name = "name"
description = "description"
dataset = protocol.Dataset()
dataset.id = id_
dataset.name = name
dataset.description = description
jsonStr = protocol.toJson(dataset)
newDataset = protocol.fromJson(jsonStr, Dataset)
self.assertEquals(dataset.id, id_)
self.assertEquals(dataset.name, name)
self.assertEquals(dataset.description, description)
datasetDict = protocol.toJsonDict(newDataset)
self.assertEquals(datasetDict['id'], id_)
self.assertEquals(datasetDict['name'], name)
self.assertEquals(datasetDict['description'], description)
def populateFromJson(self, jsonString):
# TODO validate
try:
parsed = protocol.fromJson(jsonString, protocol.Individual)
except:
raise exceptions.InvalidJsonException(jsonString)
self._created = parsed.created
self._updated = parsed.updated
self._description = parsed.description
self._species = protocol.toJsonDict(parsed.species)
self._sex = protocol.toJsonDict(parsed.sex)
attributes = {}
for key in parsed.attributes.attr:
attributes[key] = {
"values": protocol.toJsonDict(parsed.attributes.attr[key])}
self.setAttributes(attributes)
return self
def getPhenotypeAssociationSetId(self):
"""
Gets the dataset phenotype association set ID
"""
request = protocol.SearchDatasetsRequest()
response = self.sendSearchRequest(
"datasets/search",
request,
protocol.SearchDatasetsResponse)
datasetId = response.datasets[0].id
request = protocol.SearchPhenotypeAssociationSetsRequest()
request.dataset_id = datasetId
response = self.sendPostRequest(
"phenotypeassociationsets/search", request)
response = protocol.fromJson(
response.data, protocol.SearchPhenotypeAssociationSetsResponse)
return response.phenotype_association_sets[0].id
def testIntegrity(self):
# Verifies that the values we put in are exactly what we get
# back across all subclasses of SearchResponse
for class_ in [
responseClass for _, _, responseClass in protocol.postMethods
]:
instance = class_()
valueList = getattr(instance, getValueListName(class_))
valueList.add()
builder = response_builder.SearchResponseBuilder(
class_, len(valueList), 2**32)
for value in valueList:
builder.addValue(value)
builder.setNextPageToken(instance.next_page_token)
otherInstance = protocol.fromJson(builder.getSerializedResponse(),
class_)
self.assertEqual(instance, otherInstance)
def populateFromJson(self, jsonString):
try:
parsed = protocol.fromJson(jsonString, protocol.Biosample)
except:
raise exceptions.InvalidJsonException(jsonString)
self._created = parsed.created
self._updated = parsed.updated
self._description = parsed.description
self._disease = protocol.toJsonDict(parsed.disease)
self._individualId = parsed.individual_id
self._individualAgeAtCollection = protocol.toJsonDict(
parsed.individual_age_at_collection)
attributes = {}
for key in parsed.attributes.attr:
attributes[key] = {
"values": protocol.toJsonDict(parsed.attributes.attr[key])}
self.setAttributes(attributes)
return self
def testFeaturesSearchById(self):
datasetName, featureSet = self.getCGDDataSetFeatureSet()
featureId = \
"http://cancer.sanger.ac.uk/cosmic/mutation/overview?id=965"
obfuscated = self.getObfuscatedFeatureCompoundId(
datasetName, featureSet.name, featureId)
request = protocol.GetFeatureRequest
request.feature_id = obfuscated
response = self.sendGetRequest(
'/features/{}'.format(obfuscated))
feature = protocol.fromJson(response.data, protocol.Feature)
self.assertIsNotNone(feature)
self.assertEqual(request.feature_id, feature.id)
self.assertIsNotNone(feature.feature_type)
self.assertIsNotNone(feature.feature_type.term_id)
self.assertEqual(feature.reference_name, "chr10")
self.assertEqual(feature.start, 43617416)
self.assertEqual(feature.end, 43617416)
def runListReferenceBases(self, requestJson):
"""
Runs a listReferenceBases request for the specified ID and
request arguments.
"""
# In the case when an empty post request is made to the endpoint
# we instantiate an empty ListReferenceBasesRequest.
if not requestJson:
request = protocol.ListReferenceBasesRequest()
else:
try:
request = protocol.fromJson(
requestJson,
protocol.ListReferenceBasesRequest)
except protocol.json_format.ParseError:
raise exceptions.InvalidJsonException(requestJson)
compoundId = datamodel.ReferenceCompoundId.parse(request.reference_id)
referenceSet = self.getDataRepository().getReferenceSet(
compoundId.reference_set_id)
reference = referenceSet.getReference(request.reference_id)
start = request.start
end = request.end
if end == 0: # assume meant "get all"
end = reference.getLength()
if request.page_token:
pageTokenStr = request.page_token
start = paging._parsePageToken(pageTokenStr, 1)[0]
chunkSize = self._maxResponseLength
nextPageToken = None
if start + chunkSize < end:
end = start + chunkSize
nextPageToken = str(start + chunkSize)
sequence = reference.getBases(start, end)
# build response
response = protocol.ListReferenceBasesResponse()
response.offset = start
response.sequence = sequence
if nextPageToken:
response.next_page_token = nextPageToken
return protocol.toJson(response)
