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)