def benchmarkOneQuery(request, repeatLimit=3, pageLimit=3):
"""
Repeat the query several times; perhaps don't go through *all* the
pages. Returns minimum time to run backend.searchVariants() to execute
the query (as far as pageLimit allows), *not* including JSON
processing to prepare queries or parse responses.
"""
times = []
queryString = protocol.toJson(request)
for i in range(0, repeatLimit):
resultString, elapsedTime = timeOneSearch(queryString)
accruedTime = elapsedTime
pageCount = 1
token = extractNextPageToken(resultString)
# Iterate to go beyond the first page of results.
while token is not None and pageCount < pageLimit:
pageRequest = request
pageRequest.page_token = token
pageRequestString = protocol.toJson(pageRequest)
resultString, elapsedTime = timeOneSearch(pageRequestString)
accruedTime += elapsedTime
pageCount = pageCount + 1
token = extractNextPageToken(resultString)
times.append(accruedTime)
# TODO: more sophisticated statistics. Sometimes we want min(),
# sometimes mean = sum() / len(), sometimes other measures,
# perhaps exclude outliers...
# If we compute average we should throw out at least the first one.
# return sum(times[2:])/len(times[2:])
return min(times)
def testValidateObjects(self):
# test that validation works on reference sets and references
referenceSet = self._gaObject
referenceSetPe = referenceSet.toProtocolElement()
self.assertValid(protocol.ReferenceSet,
protocol.toJson(referenceSetPe))
for gaReference in referenceSet.getReferences():
reference = protocol.toJson(gaReference.toProtocolElement())
self.assertValid(protocol.Reference, reference)
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) federated search can return 404
responseData = self.deserialize(response.data, responseClass)
# responseData = protocol.fromProtobufString(response.data,
# responseClass)
self.assertTrue(
protocol.validate(protocol.toJson(responseData), responseClass))
return responseData
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) federated search can return 404
response_json = json.loads(response.data)
response = json.dumps(response_json.get('results', {}))
responseData = protocol.deserialize(response, self.serialization,
responseClass)
self.assertTrue(
protocol.validate(protocol.toJson(responseData), responseClass))
return responseData
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
# Write out a valid input
validBiosample = protocol.Biosample(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z")
validBiosample.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
biosample = bioMetadata.Biosample(
dataset, "test")
biosample.populateFromJson(protocol.toJson(validBiosample))
gaBiosample = biosample.toProtocolElement()
# Verify elements exist
self.assertEqual(gaBiosample.created, validBiosample.created)
self.assertEqual(gaBiosample.updated, validBiosample.updated)
# Invalid input
invalidBiosample = '{"bad:", "json"}'
biosample = bioMetadata.Individual(dataset, "test")
# Should fail
self.assertRaises(
exceptions.InvalidJsonException,
biosample.populateFromJson,
invalidBiosample)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
term = protocol.OntologyTerm()
term.term = "male genotypic sex"
term.term_id = "PATO:0020001"
# Write out a valid input
print(protocol.toJsonDict(term))
validIndividual = protocol.Individual(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
sex=term)
validIndividual.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
individual = bioMetadata.Individual(
dataset, "test")
individual.populateFromJson(protocol.toJson(validIndividual))
gaIndividual = individual.toProtocolElement()
# Verify elements exist
self.assertEqual(gaIndividual.created, validIndividual.created)
self.assertEqual(gaIndividual.updated, validIndividual.updated)
# Invalid input
invalidIndividual = '{"bad:", "json"}'
individual = bioMetadata.Individual(dataset, "test")
# Should fail
self.assertRaises(
exceptions.InvalidJsonException,
individual.populateFromJson,
invalidIndividual)
def assertRequestRaises(self, exceptionClass, url, request):
"""
Verifies that the specified request returns a protocol exception
corresponding to the specified exception class.
"""
self.assertRawRequestRaises(exceptionClass, url,
protocol.toJson(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 testVariantsValid(self):
end = datamodel.PysamDatamodelMixin.vcfMax
for referenceName in self._referenceNames:
iterator = self._gaObject.getVariantAnnotations(
referenceName, 0, end)
for gaVariant, gaVariantAnnotation in iterator:
self.assertValid(protocol.VariantAnnotation,
protocol.toJson(gaVariantAnnotation))
def testGoodMappings(self):
ontology = self._gaObject
for term in self._oboReader:
self.assertIn(term.id, ontology.getTermIds(term.name))
gaTerm = ontology.getGaTermByName(term.name)
self.assertTrue(
protocol.validate(protocol.toJson(gaTerm), OntologyTerm))
self.assertEqual(gaTerm.term, term.name)
self.assertIn(gaTerm.term_id, ontology.getTermIds(term.name))
def setUp(self):
self.parser = cli_repomanager.RepoManager.getParser()
self.registryPath = 'a/repo/path'
self.datasetName = "datasetName"
self.filePath = 'a/file/path'
self.dirPath = 'a/dir/path/'
self.individualName = "test"
self.biosampleName = "test"
self.individual = protocol.toJson(
protocol.Individual(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z"))
self.biosample = protocol.toJson(
protocol.Biosample(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z"))
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validFusionDetection = protocol.FusionDetection(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
fusionDetectionId="n/a",
fusionDetectionIdTier=0,
sampleId="n/a",
sampleIdTier=0,
inHousePipeline="n/a",
inHousePipelineTier=0,
svDetection="n/a",
svDetectionTier=0,
fusionDetection="n/a",
fusionDetectionTier=0,
realignment="n/a",
realignmentTier=0,
annotation="n/a",
annotationTier=0,
genomeReference="n/a",
genomeReferenceTier=0,
geneModels="n/a",
geneModelsTier=0,
alignmentId="n/a",
alignmentIdTier=0,
site="n/a",
siteTier=0)
validFusionDetection.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
fusionDetection = pipeMetadata.FusionDetection(dataset, "test")
fusionDetection.populateFromJson(protocol.toJson(validFusionDetection))
gaFusionDetection = fusionDetection.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaFusionDetection.created,
validFusionDetection.created)
self.assertEqual(gaFusionDetection.updated,
validFusionDetection.updated)
self.assertEqual(gaFusionDetection.fusionDetectionId,
validFusionDetection.fusionDetectionId)
self.assertEqual(gaFusionDetection.sampleId,
validFusionDetection.sampleId)
self.assertEqual(gaFusionDetection.site, validFusionDetection.site)
self.assertEqual(gaFusionDetection.fusionDetectionTier,
validFusionDetection.fusionDetectionTier)
# Invalid input
invalidFusionDetection = '{"bad:", "json"}'
fusionDetection = pipeMetadata.FusionDetection(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
fusionDetection.populateFromJson,
invalidFusionDetection)
def sendPostRequest(self, path, request):
"""
Sends the specified GA request object and returns the response.
"""
headers = {
'Content-type': 'application/json',
'Accept': self.serialization,
'Origin': self.exampleUrl,
}
return self.app.post(
path, headers=headers, data=protocol.toJson(request))
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validExpressionAnalysis = protocol.ExpressionAnalysis(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
expressionAnalysisId="n/a",
expressionAnalysisIdTier=0,
sampleId="n/a",
sampleIdTier=0,
readLength="n/a",
readLengthTier=0,
reference="n/a",
referenceTier=0,
alignmentTool="n/a",
alignmentToolTier=0,
bamHandling="n/a",
bamHandlingTier=0,
expressionEstimation="n/a",
expressionEstimationTier=0,
sequencingId="n/a",
sequencingIdTier=0,
site="n/a",
siteTier=0)
validExpressionAnalysis.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
expressionAnalysis = pipeMetadata.ExpressionAnalysis(dataset, "test")
expressionAnalysis.populateFromJson(
protocol.toJson(validExpressionAnalysis))
gaExpressionAnalysis = expressionAnalysis.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaExpressionAnalysis.created,
validExpressionAnalysis.created)
self.assertEqual(gaExpressionAnalysis.updated,
validExpressionAnalysis.updated)
self.assertEqual(gaExpressionAnalysis.expressionAnalysisId,
validExpressionAnalysis.expressionAnalysisId)
self.assertEqual(gaExpressionAnalysis.sampleId,
validExpressionAnalysis.sampleId)
self.assertEqual(gaExpressionAnalysis.site,
validExpressionAnalysis.site)
self.assertEqual(gaExpressionAnalysis.bamHandlingTier,
validExpressionAnalysis.bamHandlingTier)
# Invalid input
invalidExpressionAnalysis = '{"bad:", "json"}'
expressionAnalysis = pipeMetadata.ExpressionAnalysis(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
expressionAnalysis.populateFromJson,
invalidExpressionAnalysis)
def testGenotypesSearchByNameError(self):
"""
Search for feature by name with a malformed regular expression.
"""
# setup phenotype query
request = protocol.SearchFeaturesRequest()
datasetName, featureSet = self.getCGDDataSetFeatureSet()
request.feature_set_id = featureSet.id
request.name = "*" # invalid regular expression
postUrl = "features/search"
response = self.sendJsonPostRequest(postUrl, protocol.toJson(request))
self.assertEqual(400, response.status_code)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validTreatment = protocol.Treatment(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
courseNumber="n/a",
courseNumberTier=0,
therapeuticModality="n/a",
therapeuticModalityTier=0,
treatmentPlanType="n/a",
treatmentPlanTypeTier=0,
treatmentIntent="n/a",
treatmentIntentTier=0,
startDate="n/a",
startDateTier=0,
stopDate="n/a",
stopDateTier=0,
reasonForEndingTheTreatment="n/a",
reasonForEndingTheTreatmentTier=0,
responseToTreatment="n/a",
responseToTreatmentTier=0,
responseCriteriaUsed="n/a",
responseCriteriaUsedTier=0,
dateOfRecurrenceOrProgressionAfterThisTreatment="n/a",
dateOfRecurrenceOrProgressionAfterThisTreatmentTier=0,
unexpectedOrUnusualToxicityDuringTreatment="n/a",
unexpectedOrUnusualToxicityDuringTreatmentTier=0)
validTreatment.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
treatment = clinMetadata.Treatment(dataset, "test")
treatment.populateFromJson(protocol.toJson(validTreatment))
gaTreatment = treatment.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaTreatment.created, validTreatment.created)
self.assertEqual(gaTreatment.updated, validTreatment.updated)
self.assertEqual(gaTreatment.patientId, validTreatment.patientId)
self.assertEqual(gaTreatment.courseNumber, validTreatment.courseNumber)
self.assertEqual(gaTreatment.startDate, validTreatment.startDate)
# Invalid input
invalidTreatment = '{"bad:", "json"}'
treatment = clinMetadata.Treatment(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
treatment.populateFromJson, invalidTreatment)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validSequencing = protocol.Sequencing(name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
sequencingId="Sequencing_TEST",
sequencingIdTier=0,
sampleId="Sample_test",
sampleIdTier=0,
dnaLibraryKit="n/a",
dnaLibraryKitTier=0,
dnaSeqPlatform="n/a",
dnaSeqPlatformTier=0,
dnaReadLength="n/a",
dnaReadLengthTier=0,
rnaLibraryKit="n/a",
rnaLibraryKitTier=0,
rnaSeqPlatform="n/a",
rnaSeqPlatformTier=0,
rnaReadLength="n/a",
rnaReadLengthTier=0,
pcrCycles="n/a",
pcrCyclesTier=0,
extractionId="n/a",
extractionIdTier=0,
site="Toronto",
siteTier=0)
validSequencing.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
sequencing = pipeMetadata.Sequencing(dataset, "test")
sequencing.populateFromJson(protocol.toJson(validSequencing))
gaSequencing = sequencing.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaSequencing.created, validSequencing.created)
self.assertEqual(gaSequencing.updated, validSequencing.updated)
self.assertEqual(gaSequencing.sequencingId,
validSequencing.sequencingId)
self.assertEqual(gaSequencing.sampleId, validSequencing.sampleId)
self.assertEqual(gaSequencing.site, validSequencing.site)
self.assertEqual(gaSequencing.sampleIdTier,
validSequencing.sampleIdTier)
# Invalid input
invalidSequencing = '{"bad:", "json"}'
sequencing = pipeMetadata.Sequencing(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
sequencing.populateFromJson, invalidSequencing)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validSurgery = protocol.Surgery(name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
startDate="n/a",
startDateTier=0,
stopDate="n/a",
stopDateTier=0,
sampleId="n/a",
sampleIdTier=0,
collectionTimePoint="n/a",
collectionTimePointTier=0,
diagnosisDate="n/a",
diagnosisDateTier=0,
site="n/a",
siteTier=0,
type="n/a",
typeTier=0,
recordingDate="n/a",
recordingDateTier=0,
treatmentPlanId="n/a",
treatmentPlanIdTier=0,
courseNumber="1",
courseNumberTier=0)
validSurgery.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
surgery = clinMetadata.Surgery(dataset, "test")
surgery.populateFromJson(protocol.toJson(validSurgery))
gaSurgery = surgery.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaSurgery.created, validSurgery.created)
self.assertEqual(gaSurgery.updated, validSurgery.updated)
self.assertEqual(gaSurgery.patientId, validSurgery.patientId)
self.assertEqual(gaSurgery.collectionTimePoint,
validSurgery.collectionTimePoint)
self.assertEqual(gaSurgery.recordingDate, validSurgery.recordingDate)
self.assertEqual(gaSurgery.treatmentPlanIdTier,
validSurgery.treatmentPlanIdTier)
# Invalid input
invalidSurgery = '{"bad:", "json"}'
surgery = clinMetadata.Surgery(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
surgery.populateFromJson, invalidSurgery)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validLabtest = protocol.Labtest(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
startDate="n/a",
startDateTier=0,
collectionDate="n/a",
collectionDateTier=0,
endDate="n/a",
endDateTier=0,
eventType="n/a",
eventTypeTier=0,
testResults="n/a",
testResultsTier=0,
timePoint="n/a",
timePointTier=0,
recordingDate="n/a",
recordingDateTier=0,
)
validLabtest.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
labtest = clinMetadata.Labtest(dataset, "test")
labtest.populateFromJson(protocol.toJson(validLabtest))
gaLabtest = labtest.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaLabtest.created, validLabtest.created)
self.assertEqual(gaLabtest.updated, validLabtest.updated)
self.assertEqual(gaLabtest.patientId, validLabtest.patientId)
self.assertEqual(gaLabtest.eventType, validLabtest.eventType)
self.assertEqual(gaLabtest.collectionDate, validLabtest.collectionDate)
self.assertEqual(gaLabtest.recordingDateTier,
validLabtest.recordingDateTier)
# Invalid input
invalidLabtest = '{"bad:", "json"}'
labtest = clinMetadata.Labtest(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
labtest.populateFromJson, invalidLabtest)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validImmunotherapy = protocol.Immunotherapy(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
startDate="n/a",
startDateTier=0,
immunotherapyType="n/a",
immunotherapyTypeTier=0,
immunotherapyTarget="n/a",
immunotherapyTargetTier=0,
immunotherapyDetail="n/a",
immunotherapyDetailTier=0,
treatmentPlanId="n/a",
treatmentPlanIdTier=0,
courseNumber="1",
courseNumberTier=0)
validImmunotherapy.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
immunotherapy = clinMetadata.Immunotherapy(dataset, "test")
immunotherapy.populateFromJson(protocol.toJson(validImmunotherapy))
gaImmunotherapy = immunotherapy.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaImmunotherapy.created, validImmunotherapy.created)
self.assertEqual(gaImmunotherapy.updated, validImmunotherapy.updated)
self.assertEqual(gaImmunotherapy.patientId,
validImmunotherapy.patientId)
self.assertEqual(gaImmunotherapy.immunotherapyType,
validImmunotherapy.immunotherapyType)
self.assertEqual(gaImmunotherapy.immunotherapyDetailTier,
validImmunotherapy.immunotherapyDetailTier)
self.assertEqual(gaImmunotherapy.treatmentPlanId,
validImmunotherapy.treatmentPlanId)
# Invalid input
invalidImmunotherapy = '{"bad:", "json"}'
immunotherapy = clinMetadata.Immunotherapy(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
immunotherapy.populateFromJson, invalidImmunotherapy)
def testRoundTripDatasetJson(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.assertEqual(dataset.id, id_)
self.assertEqual(dataset.name, name)
self.assertEqual(dataset.description, description)
datasetDict = protocol.toJsonDict(newDataset)
self.assertEqual(datasetDict['id'], id_)
self.assertEqual(datasetDict['name'], name)
self.assertEqual(datasetDict['description'], description)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validCelltransplant = protocol.Celltransplant(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
startDate="n/a",
startDateTier=0,
cellSource="n/a",
cellSourceTier=0,
donorType="n/a",
donorTypeTier=0,
treatmentPlanId="PATIENT_TEST_1",
treatmentPlanIdTier=0,
courseNumber="1",
courseNumberTier=0)
validCelltransplant.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
celltransplant = clinMetadata.Celltransplant(dataset, "test")
celltransplant.populateFromJson(protocol.toJson(validCelltransplant))
gaCelltransplant = celltransplant.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaCelltransplant.created, validCelltransplant.created)
self.assertEqual(gaCelltransplant.updated, validCelltransplant.updated)
self.assertEqual(gaCelltransplant.patientId,
validCelltransplant.patientId)
self.assertEqual(gaCelltransplant.cellSource,
validCelltransplant.cellSource)
self.assertEqual(gaCelltransplant.courseNumber,
validCelltransplant.courseNumber)
self.assertEqual(gaCelltransplant.treatmentPlanId,
validCelltransplant.treatmentPlanId)
# Invalid input
invalidCelltransplant = '{"bad:", "json"}'
celltransplant = clinMetadata.Celltransplant(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
celltransplant.populateFromJson,
invalidCelltransplant)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validExtraction = protocol.Extraction(name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
extractionId="EXTRACTION_TEST",
extractionIdTier=0,
sampleId="n/a",
sampleIdTier=0,
rnaBlood="n/a",
rnaBloodTier=0,
dnaBlood="n/a",
dnaBloodTier=0,
rnaTissue="n/a",
rnaTissueTier=0,
dnaTissue="n/a",
dnaTissueTier=0,
site="Vancouver",
siteTier=0)
validExtraction.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
extraction = pipeMetadata.Extraction(dataset, "test")
extraction.populateFromJson(protocol.toJson(validExtraction))
gaExtraction = extraction.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaExtraction.created, validExtraction.created)
self.assertEqual(gaExtraction.updated, validExtraction.updated)
self.assertEqual(gaExtraction.extractionId,
validExtraction.extractionId)
self.assertEqual(gaExtraction.sampleId, validExtraction.sampleId)
self.assertEqual(gaExtraction.site, validExtraction.site)
self.assertEqual(gaExtraction.sampleIdTier,
validExtraction.sampleIdTier)
# Invalid input
invalidExtraction = '{"bad:", "json"}'
extraction = pipeMetadata.Extraction(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
extraction.populateFromJson, invalidExtraction)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validComplication = protocol.Complication(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
date="n/a",
dateTier=0,
lateComplicationOfTherapyDeveloped="n/a",
lateComplicationOfTherapyDevelopedTier=0,
lateToxicityDetail="n/a",
lateToxicityDetailTier=0,
suspectedTreatmentInducedNeoplasmDeveloped="n/a",
suspectedTreatmentInducedNeoplasmDevelopedTier=0,
treatmentInducedNeoplasmDetails="n/a",
treatmentInducedNeoplasmDetailsTier=0)
validComplication.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
complication = clinMetadata.Complication(dataset, "test")
complication.populateFromJson(protocol.toJson(validComplication))
gaComplication = complication.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaComplication.created, validComplication.created)
self.assertEqual(gaComplication.updated, validComplication.updated)
self.assertEqual(gaComplication.patientId, validComplication.patientId)
self.assertEqual(gaComplication.date, validComplication.date)
self.assertEqual(gaComplication.lateToxicityDetail,
validComplication.lateToxicityDetail)
self.assertEqual(gaComplication.treatmentInducedNeoplasmDetailsTier,
validComplication.treatmentInducedNeoplasmDetailsTier)
# Invalid input
invalidComplication = '{"bad:", "json"}'
complication = clinMetadata.Complication(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
complication.populateFromJson, invalidComplication)
def post(self, url, params=None, data=None):
self.checkSessionParameters()
assert url.startswith(self._urlPrefix)
suffix = url[len(self._urlPrefix):]
searchSuffix = "/search"
if suffix.endswith(searchSuffix):
datatype = suffix[1:-len(searchSuffix)]
assert datatype in self._searchMethodMap
method = self._searchMethodMap[datatype]
result = method(data, self._serialize)
else:
# ListReferenceBases is an oddball and needs to be treated
# separately.
data = json.loads(data)
args = protocol.ListReferenceBasesRequest()
args.reference_id = data.get('referenceId', "")
args.start = int(data.get('start', 0))
args.end = int(data.get('end', 0))
args.page_token = data.get('pageToken', "")
result = self._backend.runListReferenceBases(
protocol.toJson(args), self._serialize)
return DummyResponse(result)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validStudy = protocol.Study(name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
startDate="n/a",
startDateTier=0,
endDate="n/a",
endDateTier=0,
status="n/a",
statusTier=0,
recordingDate="n/a",
recordingDateTier=0)
validStudy.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
study = clinMetadata.Study(dataset, "test")
study.populateFromJson(protocol.toJson(validStudy))
gaStudy = study.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaStudy.created, validStudy.created)
self.assertEqual(gaStudy.updated, validStudy.updated)
self.assertEqual(gaStudy.patientId, validStudy.patientId)
self.assertEqual(gaStudy.startDate, validStudy.startDate)
self.assertEqual(gaStudy.status, validStudy.status)
self.assertEqual(gaStudy.recordingDateTier,
validStudy.recordingDateTier)
# Invalid input
invalidStudy = '{"bad:", "json"}'
study = clinMetadata.Study(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
study.populateFromJson, invalidStudy)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validEnrollment = protocol.Enrollment(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
enrollmentInstitution="GSC",
enrollmentInstitutionTier=0,
enrollmentApprovalDate="n/a",
enrollmentApprovalDateTier=0,
crossEnrollment="n/a",
crossEnrollmentTier=0,
otherPersonalizedMedicineStudyName="n/a",
otherPersonalizedMedicineStudyNameTier=0,
otherPersonalizedMedicineStudyId="n/a",
otherPersonalizedMedicineStudyIdTier=0,
ageAtEnrollment="n/a",
ageAtEnrollmentTier=0,
eligibilityCategory="n/a",
eligibilityCategoryTier=0,
statusAtEnrollment="n/a",
statusAtEnrollmentTier=0,
primaryOncologistName="n/a",
primaryOncologistNameTier=0,
primaryOncologistContact="n/a",
primaryOncologistContactTier=0,
referringPhysicianName="n/a",
referringPhysicianNameTier=0,
referringPhysicianContact="n/a",
referringPhysicianContactTier=0,
summaryOfIdRequest="n/a",
summaryOfIdRequestTier=0,
treatingCentreName="n/a",
treatingCentreNameTier=0,
treatingCentreProvince="n/a",
treatingCentreProvinceTier=0)
validEnrollment.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
enrollment = clinMetadata.Enrollment(dataset, "test")
enrollment.populateFromJson(protocol.toJson(validEnrollment))
gaEnrollment = enrollment.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaEnrollment.created, validEnrollment.created)
self.assertEqual(gaEnrollment.updated, validEnrollment.updated)
self.assertEqual(gaEnrollment.patientId, validEnrollment.patientId)
self.assertEqual(gaEnrollment.enrollmentInstitution,
validEnrollment.enrollmentInstitution)
self.assertEqual(gaEnrollment.statusAtEnrollment,
validEnrollment.statusAtEnrollment)
self.assertEqual(gaEnrollment.treatingCentreProvince,
validEnrollment.treatingCentreProvince)
# Invalid input
invalidEnrollment = '{"bad:", "json"}'
enrollment = clinMetadata.Enrollment(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
enrollment.populateFromJson, invalidEnrollment)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validVariantCalling = protocol.VariantCalling(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
variantCallingId="VC_TEST",
variantCallingIdTier=0,
sampleId="n/a",
sampleIdTier=0,
inHousePipeline="n/a",
inHousePipelineTier=0,
tabulate="n/a",
tabulateTier=0,
annotation="n/a",
annotationTier=0,
mergeTool="n/a",
mergeToolTier=0,
rdaToTab="n/a",
rdaToTabTier=0,
delly="n/a",
dellyTier=0,
postFilter="n/a",
postFilterTier=0,
clipFilter="n/a",
clipFilterTier=0,
cosmic="n/a",
cosmicTier=0,
dbSnp="n/a",
dbSnpTier=0,
alignmentId="n/a",
alignmentIdTier=0,
site="Vancouver",
siteTier=0,
)
validVariantCalling.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
variantCalling = pipeMetadata.VariantCalling(dataset, "test")
variantCalling.populateFromJson(protocol.toJson(validVariantCalling))
gaVariantCalling = variantCalling.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaVariantCalling.created, validVariantCalling.created)
self.assertEqual(gaVariantCalling.updated, validVariantCalling.updated)
self.assertEqual(gaVariantCalling.variantCallingId,
validVariantCalling.variantCallingId)
self.assertEqual(gaVariantCalling.sampleId,
validVariantCalling.sampleId)
self.assertEqual(gaVariantCalling.site, validVariantCalling.site)
self.assertEqual(gaVariantCalling.postFilterTier,
validVariantCalling.postFilterTier)
# Invalid input
invalidVariantCalling = '{"bad:", "json"}'
variantCalling = pipeMetadata.VariantCalling(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
variantCalling.populateFromJson,
invalidVariantCalling)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validAlignment = protocol.Alignment(name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
alignmentId="ALIGNMENT_TEST",
alignmentIdTier=0,
sampleId="n/a",
sampleIdTier=0,
inHousePipeline="n/a",
inHousePipelineTier=0,
alignmentTool="n/a",
alignmentToolTier=0,
mergeTool="n/a",
mergeToolTier=0,
markDuplicates="n/a",
markDuplicatesTier=0,
realignerTarget="n/a",
realignerTargetTier=0,
indelRealigner="n/a",
indelRealignerTier=0,
baseRecalibrator="n/a",
baseRecalibratorTier=0,
printReads="n/a",
printReadsTier=0,
idxStats="n/a",
idxStatsTier=0,
flagStat="n/a",
flagStatTier=0,
coverage="n/a",
coverageTier=0,
insertSizeMetrics="n/a",
insertSizeMetricsTier=0,
fastqc="n/a",
fastqcTier=0,
reference="n/a",
referenceTier=0,
sequencingId="n/a",
sequencingIdTier=0,
site="Montreal",
siteTier=0)
validAlignment.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
alignment = pipeMetadata.Alignment(dataset, "test")
alignment.populateFromJson(protocol.toJson(validAlignment))
gaAlignment = alignment.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaAlignment.created, validAlignment.created)
self.assertEqual(gaAlignment.updated, validAlignment.updated)
self.assertEqual(gaAlignment.alignmentId, validAlignment.alignmentId)
self.assertEqual(gaAlignment.sampleId, validAlignment.sampleId)
self.assertEqual(gaAlignment.site, validAlignment.site)
self.assertEqual(gaAlignment.mergeToolTier,
validAlignment.mergeToolTier)
# Invalid input
invalidAlignment = '{"bad:", "json"}'
alignment = pipeMetadata.Alignment(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
alignment.populateFromJson, invalidAlignment)
def testToProtocolElement(self):
dataset = datasets.Dataset('dataset1')
validRadiotherapy = protocol.Radiotherapy(
name="test",
created="2016-05-19T21:00:19Z",
updated="2016-05-19T21:00:19Z",
patientId="PATIENT_TEST",
patientIdTier=0,
courseNumber="n/a",
courseNumberTier=0,
startDate="n/a",
startDateTier=0,
stopDate="n/a",
stopDateTier=0,
therapeuticModality="n/a",
therapeuticModalityTier=0,
baseline="n/a",
baselineTier=0,
testResult="n/a",
testResultTier=0,
testResultStd="n/a",
testResultStdTier=0,
treatingCentreName="n/a",
treatingCentreNameTier=0,
startIntervalRad="n/a",
startIntervalRadTier=0,
startIntervalRadRaw="n/a",
startIntervalRadRawTier=0,
recordingDate="n/a",
recordingDateTier=0,
adjacentFields="n/a",
adjacentFieldsTier=0,
adjacentFractions="n/a",
adjacentFractionsTier=0,
complete="n/a",
completeTier=0,
brachytherapyDose="n/a",
brachytherapyDoseTier=0,
radiotherapyDose="n/a",
radiotherapyDoseTier=0,
siteNumber="n/a",
siteNumberTier=0,
technique="n/a",
techniqueTier=0,
treatedRegion="n/a",
treatedRegionTier=0,
treatmentPlanId="n/a",
treatmentPlanIdTier=0,
radiationType="n/a",
radiationTypeTier=0,
radiationSite="n/a",
radiationSiteTier=0,
totalDose="n/a",
totalDoseTier=0,
boostSite="n/a",
boostSiteTier=0,
boostDose="n/a",
boostDoseTier=0)
validRadiotherapy.attributes.attr['test']. \
values.add().string_value = 'test-info'
# pass through protocol creation
radiotherapy = clinMetadata.Radiotherapy(dataset, "test")
radiotherapy.populateFromJson(protocol.toJson(validRadiotherapy))
gaRadiotherapy = radiotherapy.toProtocolElement()
# Verify select elements exist
self.assertEqual(gaRadiotherapy.created, validRadiotherapy.created)
self.assertEqual(gaRadiotherapy.updated, validRadiotherapy.updated)
self.assertEqual(gaRadiotherapy.patientId, validRadiotherapy.patientId)
self.assertEqual(gaRadiotherapy.brachytherapyDose,
validRadiotherapy.brachytherapyDose)
self.assertEqual(gaRadiotherapy.adjacentFractions,
validRadiotherapy.adjacentFractions)
self.assertEqual(gaRadiotherapy.treatmentPlanIdTier,
validRadiotherapy.treatmentPlanIdTier)
# Invalid input
invalidRadiotherapy = '{"bad:", "json"}'
radiotherapy = clinMetadata.Radiotherapy(dataset, "test")
# Should fail
self.assertRaises(exceptions.InvalidJsonException,
radiotherapy.populateFromJson, invalidRadiotherapy)
