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 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 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 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') 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') 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') 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 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') 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 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') validConsent = protocol.Consent(name="test", created="2016-05-19T21:00:19Z", updated="2016-05-19T21:00:19Z", patientId="PATIENT_TEST", patientIdTier=0, consentId="n/a", consentIdTier=0, consentDate="n/a", consentDateTier=0, consentVersion="n/a", consentVersionTier=0, patientConsentedTo="n/a", patientConsentedToTier=0, reasonForRejection="n/a", reasonForRejectionTier=0, wasAssentObtained="n/a", wasAssentObtainedTier=0, dateOfAssent="n/a", dateOfAssentTier=0, assentFormVersion="n/a", assentFormVersionTier=0, ifAssentNotObtainedWhyNot="n/a", ifAssentNotObtainedWhyNotTier=0, reconsentDate="n/a", reconsentDateTier=0, reconsentVersion="n/a", reconsentVersionTier=0, consentingCoordinatorName="n/a", consentingCoordinatorNameTier=0, previouslyConsented="n/a", previouslyConsentedTier=0, nameOfOtherBiobank="n/a", nameOfOtherBiobankTier=0, hasConsentBeenWithdrawn="n/a", hasConsentBeenWithdrawnTier=0, dateOfConsentWithdrawal="n/a", dateOfConsentWithdrawalTier=0, typeOfConsentWithdrawal="n/a", typeOfConsentWithdrawalTier=0, reasonForConsentWithdrawal="n/a", reasonForConsentWithdrawalTier=0, consentFormComplete="n/a", consentFormCompleteTier=0) validConsent.attributes.attr['test']. \ values.add().string_value = 'test-info' # pass through protocol creation consent = clinMetadata.Consent(dataset, "test") consent.populateFromJson(protocol.toJson(validConsent)) gaConsent = consent.toProtocolElement() # Verify select elements exist self.assertEqual(gaConsent.created, validConsent.created) self.assertEqual(gaConsent.updated, validConsent.updated) self.assertEqual(gaConsent.patientId, validConsent.patientId) self.assertEqual(gaConsent.consentId, validConsent.consentId) self.assertEqual(gaConsent.consentFormComplete, validConsent.consentFormComplete) self.assertEqual(gaConsent.previouslyConsented, validConsent.previouslyConsented) # Invalid input invalidConsent = '{"bad:", "json"}' consent = clinMetadata.Consent(dataset, "test") # Should fail self.assertRaises(exceptions.InvalidJsonException, consent.populateFromJson, invalidConsent)
def testToProtocolElement(self): dataset = datasets.Dataset('dataset1') validTumourboard = protocol.Tumourboard( name="test", created="2016-05-19T21:00:19Z", updated="2016-05-19T21:00:19Z", patientId="PATIENT_TEST", patientIdTier=0, dateOfMolecularTumorBoard="n/a", dateOfMolecularTumorBoardTier=0, typeOfSampleAnalyzed="n/a", typeOfSampleAnalyzedTier=0, typeOfTumourSampleAnalyzed="n/a", typeOfTumourSampleAnalyzedTier=0, analysesDiscussed="n/a", analysesDiscussedTier=0, somaticSampleType="n/a", somaticSampleTypeTier=0, normalExpressionComparator="n/a", normalExpressionComparatorTier=0, diseaseExpressionComparator="n/a", diseaseExpressionComparatorTier=0, hasAGermlineVariantBeenIdentifiedByProfilingThatMayPredisposeToCancer ="n/a", hasAGermlineVariantBeenIdentifiedByProfilingThatMayPredisposeToCancerTier =0, actionableTargetFound="n/a", actionableTargetFoundTier=0, molecularTumorBoardRecommendation="n/a", molecularTumorBoardRecommendationTier=0, germlineDnaSampleId="n/a", germlineDnaSampleIdTier=0, tumorDnaSampleId="n/a", tumorDnaSampleIdTier=0, tumorRnaSampleId="n/a", tumorRnaSampleIdTier=0, germlineSnvDiscussed="n/a", germlineSnvDiscussedTier=0, somaticSnvDiscussed="n/a", somaticSnvDiscussedTier=0, cnvsDiscussed="n/a", cnvsDiscussedTier=0, structuralVariantDiscussed="n/a", structuralVariantDiscussedTier=0, classificationOfVariants="n/a", classificationOfVariantsTier=0, clinicalValidationProgress="n/a", clinicalValidationProgressTier=0, typeOfValidation="n/a", typeOfValidationTier=0, agentOrDrugClass="n/a", agentOrDrugClassTier=0, levelOfEvidenceForExpressionTargetAgentMatch="n/a", levelOfEvidenceForExpressionTargetAgentMatchTier=0, didTreatmentPlanChangeBasedOnProfilingResult="n/a", didTreatmentPlanChangeBasedOnProfilingResultTier=0, howTreatmentHasAlteredBasedOnProfiling="n/a", howTreatmentHasAlteredBasedOnProfilingTier=0, reasonTreatmentPlanDidNotChangeBasedOnProfiling="n/a", reasonTreatmentPlanDidNotChangeBasedOnProfilingTier=0, detailsOfTreatmentPlanImpact="n/a", detailsOfTreatmentPlanImpactTier=0, patientOrFamilyInformedOfGermlineVariant="n/a", patientOrFamilyInformedOfGermlineVariantTier=0, patientHasBeenReferredToAHereditaryCancerProgramBasedOnThisMolecularProfiling ="n/a", patientHasBeenReferredToAHereditaryCancerProgramBasedOnThisMolecularProfilingTier =0, summaryReport="n/a", summaryReportTier=0) validTumourboard.attributes.attr['test']. \ values.add().string_value = 'test-info' # pass through protocol creation tumourboard = clinMetadata.Tumourboard(dataset, "test") tumourboard.populateFromJson(protocol.toJson(validTumourboard)) gaTumourboard = tumourboard.toProtocolElement() # Verify select elements exist self.assertEqual(gaTumourboard.created, validTumourboard.created) self.assertEqual(gaTumourboard.updated, validTumourboard.updated) self.assertEqual(gaTumourboard.patientId, validTumourboard.patientId) self.assertEqual(gaTumourboard.dateOfMolecularTumorBoard, validTumourboard.dateOfMolecularTumorBoard) self.assertEqual(gaTumourboard.typeOfValidation, validTumourboard.typeOfValidation) self.assertEqual(gaTumourboard.summaryReportTier, validTumourboard.summaryReportTier) # Invalid input invalidTumourboard = '{"bad:", "json"}' tumourboard = clinMetadata.Tumourboard(dataset, "test") # Should fail self.assertRaises(exceptions.InvalidJsonException, tumourboard.populateFromJson, invalidTumourboard)
def testToProtocolElement(self): dataset = datasets.Dataset('dataset1') validOutcome = protocol.Outcome( name="test", created="2016-05-19T21:00:19Z", updated="2016-05-19T21:00:19Z", patientId="PATIENT_TEST", patientIdTier=0, physicalExamId="n/a", physicalExamIdTier=0, dateOfAssessment="n/a", dateOfAssessmentTier=0, diseaseResponseOrStatus="n/a", diseaseResponseOrStatusTier=0, otherResponseClassification="n/a", otherResponseClassificationTier=0, minimalResidualDiseaseAssessment="n/a", minimalResidualDiseaseAssessmentTier=0, methodOfResponseEvaluation="n/a", methodOfResponseEvaluationTier=0, responseCriteriaUsed="n/a", responseCriteriaUsedTier=0, summaryStage="n/a", summaryStageTier=0, sitesOfAnyProgressionOrRecurrence="n/a", sitesOfAnyProgressionOrRecurrenceTier=0, vitalStatus="n/a", vitalStatusTier=0, height="n/a", heightTier=0, weight="n/a", weightTier=0, heightUnits="n/a", heightUnitsTier=0, weightUnits="n/a", weightUnitsTier=0, performanceStatus="n/a", performanceStatusTier=0) validOutcome.attributes.attr['test']. \ values.add().string_value = 'test-info' # pass through protocol creation outcome = clinMetadata.Outcome(dataset, "test") outcome.populateFromJson(protocol.toJson(validOutcome)) gaOutcome = outcome.toProtocolElement() # Verify select elements exist self.assertEqual(gaOutcome.created, validOutcome.created) self.assertEqual(gaOutcome.updated, validOutcome.updated) self.assertEqual(gaOutcome.patientId, validOutcome.patientId) self.assertEqual(gaOutcome.physicalExamId, validOutcome.physicalExamId) self.assertEqual(gaOutcome.summaryStage, validOutcome.summaryStage) self.assertEqual(gaOutcome.performanceStatusTier, validOutcome.performanceStatusTier) # Invalid input invalidOutcome = '{"bad:", "json"}' outcome = clinMetadata.Outcome(dataset, "test") # Should fail self.assertRaises(exceptions.InvalidJsonException, outcome.populateFromJson, invalidOutcome)
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') 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') validSlide = protocol.Slide(name="test", created="2016-05-19T21:00:19Z", updated="2016-05-19T21:00:19Z", patientId="PATIENT_TEST", patientIdTier=0, sampleId="n/a", sampleIdTier=0, slideId="n/a", slideIdTier=0, slideOtherId="n/a", slideOtherIdTier=0, lymphocyteInfiltrationPercent="n/a", lymphocyteInfiltrationPercentTier=0, tumorNucleiPercent="n/a", tumorNucleiPercentTier=0, monocyteInfiltrationPercent="n/a", monocyteInfiltrationPercentTier=0, normalCellsPercent="n/a", normalCellsPercentTier=0, tumorCellsPercent="n/a", tumorCellsPercentTier=0, stromalCellsPercent="n/a", stromalCellsPercentTier=0, eosinophilInfiltrationPercent="n/a", eosinophilInfiltrationPercentTier=0, neutrophilInfiltrationPercent="n/a", neutrophilInfiltrationPercentTier=0, granulocyteInfiltrationPercent="n/a", granulocyteInfiltrationPercentTier=0, necrosisPercent="n/a", necrosisPercentTier=0, inflammatoryInfiltrationPercent="n/a", inflammatoryInfiltrationPercentTier=0, proliferatingCellsNumber="n/a", proliferatingCellsNumberTier=0, sectionLocation="n/a", sectionLocationTier=0) validSlide.attributes.attr['test']. \ values.add().string_value = 'test-info' # pass through protocol creation slide = clinMetadata.Slide(dataset, "test") slide.populateFromJson(protocol.toJson(validSlide)) gaSlide = slide.toProtocolElement() # Verify select elements exist self.assertEqual(gaSlide.created, validSlide.created) self.assertEqual(gaSlide.updated, validSlide.updated) self.assertEqual(gaSlide.patientId, validSlide.patientId) self.assertEqual(gaSlide.slideId, validSlide.slideId) self.assertEqual(gaSlide.granulocyteInfiltrationPercent, validSlide.granulocyteInfiltrationPercent) self.assertEqual(gaSlide.sectionLocationTier, validSlide.sectionLocationTier) # Invalid input invalidSlide = '{"bad:", "json"}' slide = clinMetadata.Slide(dataset, "test") # Should fail self.assertRaises(exceptions.InvalidJsonException, slide.populateFromJson, invalidSlide)
def testToProtocolElement(self): dataset = datasets.Dataset('dataset1') validChemotherapy = protocol.Chemotherapy( 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, systematicTherapyAgentName="n/a", systematicTherapyAgentNameTier=0, route="n/a", routeTier=0, dose="n/a", doseTier=0, doseFrequency="n/a", doseFrequencyTier=0, doseUnit="n/a", doseUnitTier=0, daysPerCycle="n/a", daysPerCycleTier=0, numberOfCycle="n/a", numberOfCycleTier=0, treatmentIntent="n/a", treatmentIntentTier=0, treatingCentreName="n/a", treatingCentreNameTier=0, type="n/a", typeTier=0, protocolCode="n/a", protocolCodeTier=0, recordingDate="n/a", recordingDateTier=0, treatmentPlanId="n/a", treatmentPlanIdTier=0) validChemotherapy.attributes.attr['test']. \ values.add().string_value = 'test-info' # pass through protocol creation chemotherapy = clinMetadata.Chemotherapy(dataset, "test") chemotherapy.populateFromJson(protocol.toJson(validChemotherapy)) gaChemotherapy = chemotherapy.toProtocolElement() # Verify select elements exist self.assertEqual(gaChemotherapy.created, validChemotherapy.created) self.assertEqual(gaChemotherapy.updated, validChemotherapy.updated) self.assertEqual(gaChemotherapy.patientId, validChemotherapy.patientId) self.assertEqual(gaChemotherapy.systematicTherapyAgentName, validChemotherapy.systematicTherapyAgentName) self.assertEqual(gaChemotherapy.protocolCode, validChemotherapy.protocolCode) self.assertEqual(gaChemotherapy.treatmentPlanIdTier, validChemotherapy.treatmentPlanIdTier) # Invalid input invalidChemotherapy = '{"bad:", "json"}' chemotherapy = clinMetadata.Chemotherapy(dataset, "test") # Should fail self.assertRaises(exceptions.InvalidJsonException, chemotherapy.populateFromJson, invalidChemotherapy)
def testToProtocolElement(self): dataset = datasets.Dataset('dataset1') validPatient = protocol.Patient( name="test", created="2016-05-19T21:00:19Z", updated="2016-05-19T21:00:19Z", patientId="PATIENT_TEST", patientIdTier=0, otherIds="n/a", otherIdsTier=0, dateOfBirth="n/a", dateOfBirthTier=0, gender="Male", genderTier=0, ethnicity="n/a", ethnicityTier=0, race="n/a", raceTier=0, provinceOfResidence="British Columbia", provinceOfResidenceTier=0, dateOfDeath="n/a", dateOfDeathTier=0, causeOfDeath="n/a", causeOfDeathTier=0, autopsyTissueForResearch="n/a", autopsyTissueForResearchTier=0, priorMalignancy="n/a", priorMalignancyTier=0, dateOfPriorMalignancy="n/a", dateOfPriorMalignancyTier=0, familyHistoryAndRiskFactors="n/a", familyHistoryAndRiskFactorsTier=0, familyHistoryOfPredispositionSyndrome="n/a", familyHistoryOfPredispositionSyndromeTier=0, detailsOfPredispositionSyndrome="n/a", detailsOfPredispositionSyndromeTier=0, geneticCancerSyndrome="n/a", geneticCancerSyndromeTier=0, otherGeneticConditionOrSignificantComorbidity="n/a", otherGeneticConditionOrSignificantComorbidityTier=0, occupationalOrEnvironmentalExposure="n/a", occupationalOrEnvironmentalExposureTier=0, ) validPatient.attributes.attr['test']. \ values.add().string_value = 'test-info' # pass through protocol creation patient = clinMetadata.Patient(dataset, "test") patient.populateFromJson(protocol.toJson(validPatient)) gaPatient = patient.toProtocolElement() # Verify select elements exist self.assertEqual(gaPatient.created, validPatient.created) self.assertEqual(gaPatient.updated, validPatient.updated) self.assertEqual(gaPatient.patientId, validPatient.patientId) self.assertEqual(gaPatient.otherIds, validPatient.otherIds) self.assertEqual(gaPatient.dateOfBirth, validPatient.dateOfBirth) self.assertEqual(gaPatient.gender, validPatient.gender) # Invalid input invalidPatient = '{"bad:", "json"}' patient = clinMetadata.Patient(dataset, "test") # Should fail self.assertRaises(exceptions.InvalidJsonException, patient.populateFromJson, invalidPatient)
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)
def testToProtocolElement(self): dataset = datasets.Dataset('dataset1') validDiagnosis = protocol.Diagnosis( name="test", created="2016-05-19T21:00:19Z", updated="2016-05-19T21:00:19Z", patientId="PATIENT_TEST", patientIdTier=0, diagnosisId="n/a", diagnosisIdTier=0, diagnosisDate="n/a", diagnosisDateTier=0, ageAtDiagnosis="n/a", ageAtDiagnosisTier=0, cancerType="n/a", cancerTypeTier=0, classification="n/a", classificationTier=0, cancerSite="n/a", cancerSiteTier=0, histology="n/a", histologyTier=0, methodOfDefinitiveDiagnosis="n/a", methodOfDefinitiveDiagnosisTier=0, sampleType="n/a", sampleTypeTier=0, sampleSite="n/a", sampleSiteTier=0, tumorGrade="n/a", tumorGradeTier=0, gradingSystemUsed="n/a", gradingSystemUsedTier=0, sitesOfMetastases="n/a", sitesOfMetastasesTier=0, stagingSystem="n/a", stagingSystemTier=0, versionOrEditionOfTheStagingSystem="n/a", versionOrEditionOfTheStagingSystemTier=0, specificTumorStageAtDiagnosis="n/a", specificTumorStageAtDiagnosisTier=0, prognosticBiomarkers="n/a", prognosticBiomarkersTier=0, biomarkerQuantification="n/a", biomarkerQuantificationTier=0, additionalMolecularTesting="n/a", additionalMolecularTestingTier=0, additionalTestType="n/a", additionalTestTypeTier=0, laboratoryName="n/a", laboratoryNameTier=0, laboratoryAddress="n/a", laboratoryAddressTier=0, siteOfMetastases="n/a", siteOfMetastasesTier=0, stagingSystemVersion="n/a", stagingSystemVersionTier=0, specificStage="n/a", specificStageTier=0, cancerSpecificBiomarkers="n/a", cancerSpecificBiomarkersTier=0, additionalMolecularDiagnosticTestingPerformed="n/a", additionalMolecularDiagnosticTestingPerformedTier=0, additionalTest="n/a", additionalTestTier=0) validDiagnosis.attributes.attr['test']. \ values.add().string_value = 'test-info' # pass through protocol creation diagnosis = clinMetadata.Diagnosis(dataset, "test") diagnosis.populateFromJson(protocol.toJson(validDiagnosis)) gaDiagnosis = diagnosis.toProtocolElement() # Verify select elements exist self.assertEqual(gaDiagnosis.created, validDiagnosis.created) self.assertEqual(gaDiagnosis.updated, validDiagnosis.updated) self.assertEqual(gaDiagnosis.patientId, validDiagnosis.patientId) self.assertEqual(gaDiagnosis.cancerType, validDiagnosis.cancerType) self.assertEqual(gaDiagnosis.cancerSite, validDiagnosis.cancerSite) self.assertEqual(gaDiagnosis.additionalTest, validDiagnosis.additionalTest) # Invalid input invalidDiagnosis = '{"bad:", "json"}' diagnosis = clinMetadata.Diagnosis(dataset, "test") # Should fail self.assertRaises(exceptions.InvalidJsonException, diagnosis.populateFromJson, invalidDiagnosis)
def testToProtocolElement(self): dataset = datasets.Dataset('dataset1') validSample = protocol.Sample(name="test", created="2016-05-19T21:00:19Z", updated="2016-05-19T21:00:19Z", patientId="PATIENT_TEST", patientIdTier=0, sampleId="SAMPLE_TEST", sampleIdTier=0, diagnosisId="DIAGNOSIS_TEST", diagnosisIdTier=0, localBiobankId="n/a", localBiobankIdTier=0, collectionDate="n/a", collectionDateTier=0, collectionHospital="n/a", collectionHospitalTier=0, sampleType="n/a", sampleTypeTier=0, tissueDiseaseState="n/a", tissueDiseaseStateTier=0, anatomicSiteTheSampleObtainedFrom="n/a", anatomicSiteTheSampleObtainedFromTier=0, cancerType="n/a", cancerTypeTier=0, cancerSubtype="n/a", cancerSubtypeTier=0, pathologyReportId="n/a", pathologyReportIdTier=0, morphologicalCode="n/a", morphologicalCodeTier=0, topologicalCode="n/a", topologicalCodeTier=0, shippingDate="n/a", shippingDateTier=0, receivedDate="n/a", receivedDateTier=0, qualityControlPerformed="n/a", qualityControlPerformedTier=0, estimatedTumorContent="n/a", estimatedTumorContentTier=0, quantity="n/a", quantityTier=0, units="n/a", unitsTier=0, associatedBiobank="n/a", associatedBiobankTier=0, otherBiobank="n/a", otherBiobankTier=0, sopFollowed="n/a", sopFollowedTier=0, ifNotExplainAnyDeviation="n/a", ifNotExplainAnyDeviationTier=0) validSample.attributes.attr['test']. \ values.add().string_value = 'test-info' # pass through protocol creation sample = clinMetadata.Sample(dataset, "test") sample.populateFromJson(protocol.toJson(validSample)) gaSample = sample.toProtocolElement() # Verify select elements exist self.assertEqual(gaSample.created, validSample.created) self.assertEqual(gaSample.updated, validSample.updated) self.assertEqual(gaSample.patientId, validSample.patientId) self.assertEqual(gaSample.sampleId, validSample.sampleId) self.assertEqual(gaSample.diagnosisId, validSample.diagnosisId) self.assertEqual(gaSample.associatedBiobankTier, validSample.associatedBiobankTier) # Invalid input invalidSample = '{"bad:", "json"}' sample = clinMetadata.Sample(dataset, "test") # Should fail self.assertRaises(exceptions.InvalidJsonException, sample.populateFromJson, invalidSample)
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)