class InsersionMethodTesting(unittest.TestCase): time.sleep(2) indel_any = { 'TYPE': 'INDEL', 'REGION': 'INTRONIC', 'IMPACT': { "INDEL_AMOUNT": 5, "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } indel_spec = { 'TYPE': 'INDEL', 'REGION': 'CODING', 'IMPACT': { "INDEL_AMOUNT": 8, "START": 129814200 }, "ZYGOSITY": "HETEROZYGOUS" } SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"] positive_transcript = Transcript(SOX9_uid, "grch38") TOR1A_uid = get_all_transcripts("TOR1A", "grch38")[0]["qualifiers"]["uid"] negative_transcript = Transcript(TOR1A_uid, "grch38") indel_any = Indel(indel_any, positive_transcript) indel_spec = Indel(indel_spec, negative_transcript) # test 7 def test_check_insertion_generation(self): self.assertEqual(len(self.indel_any.get_insertion_str(50)), 50) # test 8 def test_get_insertion_any(self): insertion = self.indel_any.get_insertion() self.assertEqual(len(insertion["alt"]), 6) # test 9 def test_get_insertion_spec(self): insertion = self.indel_spec.get_insertion() self.assertEqual(insertion["pos"], 129814199) self.assertEqual(len(insertion["alt"]), 9) # test 10 def test_get_insertion_row(self): insertion = self.indel_spec.get_vcf_row() self.assertEqual(insertion['chrom'], "9") self.assertEqual(insertion['pos'], '129814200') self.assertEqual(len(insertion['alt']), 9) print(insertion)
def get_clingen_clinvar_str_api(genome, transcript_uid, region=None): if (region is None ): response = jsonify([]) return response transcript = Transcript(transcript_uid, genome) res = [] if region in ["UTR", "INTRONIC", "GENIC", "CODING"]: region_tuple = transcript.get_requested_region("GENIC") else: start = int(region.split(":")[1].split("-")[0])-1 end = int(region.split(":")[1].split("-")[1]) region_tuple = [(start, end)] chrom = transcript.get_chr() location = "overlapping" # get full genic or custom region if request.path.startswith("/get_str"): res = get_strs(region_tuple[0][0]+1, region_tuple[0][1], chrom, genome, location) #add 1 to start to make 1 based for api call elif request.path.startswith("/get_clinvar"): res = get_clinvars(region_tuple[0][0]+1, region_tuple[0][1], chrom, genome, location) #add 1 to start to make 1 based for api call else: res = get_cnvs(region_tuple[0][0]+1, region_tuple[0][1], chrom, genome, location) #add 1 to start to make 1 based for api call # cut if UTR, INTRONIC, or CODING if region in ["UTR", "INTRONIC", "CODING"]: subregions = transcript.get_requested_region(region) res = extract_subregions(res, subregions, region) response = jsonify(res) return response
class SNVCreationTests(unittest.TestCase): time.sleep(1) XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(XKR8_uid, "grch38") # test 1 def test_wrong_type(self): snv = { "TYPE": "SNP", "REGION": "INTRONIC", "IMPACT": { "SNV_TYPE": "A", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): SNV(snv, self.transcript) # test 2 def test_wrong_type_impact(self): snv = { "TYPE": "SNV", "REGION": "INTRONIC", "IMPACT": { "SNV_TYPE": "WRONG", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): SNV(snv, self.transcript)
class clinvarTests(unittest.TestCase): SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(SOX9_uid, "grch38") # test 1 def test_clinvar(self): clinvar = { "TYPE": "CLINVAR", "REGION": "GENIC", "IMPACT": { "CLINVAR_ID": 507525 }, "ZYGOSITY": "HETEROZYGOUS" } clinvar = ClinVar(clinvar, self.transcript) row = clinvar.get_vcf_row() self.assertEqual(row["chrom"], "17") self.assertEqual(row["pos"], "72121409") self.assertEqual(row["ref"], "C") self.assertEqual(row["alt"], "T") # test 2 def test_clinvar_wrong(self): clinvar = { "TYPE": "CLINVAR", "REGION": "GENIC", "IMPACT": { "CLINVAR_ID": 2000000000 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): ClinVar(clinvar, self.transcript)
def test_get_codon_positive_medium(self): XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] XKR8 = Transcript(XKR8_uid, "grch38") codon = XKR8.get_codon_from_pos(27963497) self.assertEqual(codon[0], "TGC") self.assertEqual(codon[1], 0) self.assertEqual(codon[2], 1)
def test_get_codon_negative_hard(self): SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"] SOX18 = Transcript(SOX18_uid, "grch38") codon = SOX18.get_codon_from_pos(64048168) self.assertEqual(codon[0], "GGC") self.assertEqual(codon[1], 2) self.assertEqual(codon[2], -1)
def test_get_sequence_stranded(self): TOR1A_uid = get_all_transcripts("TOR1A", "grch38")[0]["qualifiers"]["uid"] TOR1A = Transcript(TOR1A_uid, "grch38") sequence_positive = TOR1A.get_seq() sequence_negative = TOR1A.get_seq(True) self.assertEqual( Seq(sequence_positive).reverse_complement(), sequence_negative)
def test_get_coding_negative_exons(self): TOR1A_uid = get_all_transcripts("TOR1A", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(TOR1A_uid, "grch38") exons = transcript.get_coding() exon_seq = transcript.get_seq_from_pos(exons) self.assertEqual( exon_seq, "ATGAAGCTGGGCCGGGCCGTGCTGGGCCTGCTGCTGCTGGCGCCGTCCGTGGTGCAGGCGGTGGAGCCCATCAGCCTGGGACTGGCCCTGGCCGGCGTCCTCACCGGCTACATCTACCCGCGTCTCTACTGCCTCTTCGCCGAGTGCTGCGGGCAGAAGCGGAGCCTTAGCCGGGAGGCACTGCAGAAGGATCTGGACGACAACCTCTTTGGACAGCATCTTGCAAAGAAAATCATCTTAAATGCCGTGTTTGGTTTCATAAACAACCCAAAGCCCAAGAAACCTCTCACGCTCTCCCTGCACGGGTGGACAGGCACCGGCAAAAATTTCGTCAGCAAGATCATCGCAGAGAATATTTACGAGGGTGGTCTGAACAGTGACTATGTCCACCTGTTTGTGGCCACATTGCACTTTCCACATGCTTCAAACATCACCTTGTACAAGGATCAGTTACAGTTGTGGATTCGAGGCAACGTGAGTGCCTGTGCGAGGTCCATCTTCATATTTGATGAAATGGATAAGATGCATGCAGGCCTCATAGATGCCATCAAGCCTTTCCTCGACTATTATGACCTGGTGGATGGGGTCTCCTACCAGAAAGCCATGTTCATATTTCTCAGCAATGCTGGAGCAGAAAGGATCACAGATGTGGCTTTGGATTTCTGGAGGAGTGGAAAGCAGAGGGAAGACATCAAGCTCAAAGACATTGAACACGCGTTGTCTGTGTCGGTTTTCAATAACAAGAACAGTGGCTTCTGGCACAGCAGCTTAATTGACCGGAACCTCATTGATTATTTTGTTCCCTTCCTCCCCCTGGAATACAAACACCTAAAAATGTGTATCCGAGTGGAAATGCAGTCCCGAGGCTATGAAATTGATGAAGACATTGTAAGCAGAGTGGCTGAGGAGATGACATTTTTCCCCAAAGAGGAGAGAGTTTTCTCAGATAAAGGCTGCAAAACGGTGTTCACCAAGTTAGATTATTACTACGATGATTGA" )
def test_noncoding_gene(self): PRDM15_uid = get_all_transcripts("PRDM15", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(PRDM15_uid, "grch38") exons = transcript.get_coding() exon_seq = transcript.get_seq_from_pos(exons) self.assertEqual( exon_seq, "ATGGCTGAAGATGGGAGCGAAGAGATCATGTTCATCTGGTGTGAAGACTGCAGCCAGTACCACGACTCCGAATGTCCCGAGCTGGGCCCAGTGGTCATGGTCAAAGACTCCTTTGTGTTAAGCAGGGCAAGGTCATCCCTTCCTCCCAACTTGGAGATCAGACGACTGGAAGATGGAGCCGAGGGGGTGTTCGCCATCACTCAGCTCGTCAAGCGGACACAGTTCGGTCCCTTTGAGTCCAGGAGGGTCGCCAAATGGGAAAAGGAGTCTGCATTTCCCCTGAAGGTGTTCCAGAAGGACGGGCACCCCGTGTGCTTCGACACCTCCAACGAGGATGACTGCAACTGGATGATGCTGGTGCGGCCAGCGGCGGAGGCCGAGCACCAGAACCTGACGGCCTACCAGCACGGCAGCGACGTGTACTTCACCACCTCCAGAGACATCCCCCCGGGTACCGAGCTGCGCGTGTGGTATGCGGCCTTCTATGCCAAGAAGATGGACAAGCCCATGCTGAAGCAGGCCGGCTCTGGCGTCCACGCTGCAGGCACCCCAGAAAACAGCGCCCCCGTGGAGTCGGAGCCCAGCCAGTGGGCGTGTAAAGTGTGTTCTGCCACCTTCCTGGAGCTGCAGCTCCTCAATGAACATCTGTTGGGCCACTTAGAACAAGCCAAAAGCCTTCCTCCAGGCAGCCAAAGCGAGGCAGCAGCTCCCGAGAAGGAGCAGGACACACCCCGGGGGGAACCCCCTGCAGTGCCCGAGAGCGAGAATGTTGCCACCAAAGAACAGAAGAAAAAGCCTCGAAGGGGGAGAAAACCCAAAGTGTCCAAAGCTGAGCAGCCTCTAGTCATCGTGGAAGACAAGGAACCCACAGAGCAAGTGGCAGAGATCATTACCGAGGTCCCTCCGGATGAGCCTGTGAGTGCAACGCCAGATGAGCGGATCATGGAGCTGGTTCTGGGGAAGCTGGCCACCACCACCACTGACACCAGCTCGGTTCCAAAGTTCACCCATCATCAGAATAACACCATCACGCTCAAGAGGAGCTTAATTCTCTCAAGCAGACACGGCATCCGGCGCAAGCTCATCAAACAGCTCGGGGAGCACAAGCGGGTTTACCAGTGCAATATCTGCAGCAAGATCTTCCAGAACAGCAGCAACCTGAGCAGGCACGTGCGCTCGCATGGTGACAAGCTGTTTAAGTGCGAAGAGTGTGCAAAATTGTTCAGCCGCAAAGAGAGCCTAAAGCAGCACGTTTCCTACAAGCACAGCAGGAACGAGGTGGACGGCGAGTACAGGTACCGCTGCGGCACTTGTGAGAAGACCTTCCGCATCGAGAGCGCGCTGGAGTTCCACAACTGCAGGACAGATGACAAGACGTTCCAATGTGAGATGTGTTTCAGATTCTTCTCCACCAACAGCAACCTCTCCAAGCACAAGAAGAAGCACGGCGACAAGAAGTTTGCCTGTGAGGTCTGCAGCAAGATGTTCTACCGCAAGGACGTCATGCTGGACCACCAGCGCCGGCACCTGGAAGGAGTGCGGCGAGTGAAGCGAGAGGACCTGGAGGCCGGTGGGGAGAACCTGGTCCGTTACAAGAAGGAGCCTTCCGGGTGCCCGGTGTGTGGCAAGGTGTTCTCCTGCCGGAGCAATATGAACAAGCACCTGCTCACCCACGGCGACAAGAAGTACACCTGCGAGATCTGCGGGCGCAAGTTCTTCCGCGTGGATGTGCTCAGGGACCACATCCATGTCCACTTCAAGGACATCGCGTTGATGGATGACCACCAGAGGGAAGAGTTTATCGGCAAGATCGGGATCTCCTCGGAAGAAAACGATGACAATTCTGACGAGAGCGCAGACTCGGAGCCTCACAAGTACAGCTGCAAGCGGTGCCAGCTCACCTTCGGCCGGGGGAAGGAGTACCTGAAGCACATCATGGAGGTGCACAAGGAGAAGGGCTATGGCTGCAGCATCTGCAACCGGCGCTTTGCACTGAAGGCCACCTACCACGCCCACATGGTCATCCACCGTGAAAACCTGCCGGACCCCAACGTGCAGAAGTACATCCACCCCTGCGAGATCTGCGGGCGGATCTTCAACAGCATCGGGAACCTGGAGCGCCACAAGCTCATCCACACAGGTGTGAAGAGCCACGCCTGCGAGCAGTGTGGGAAGTCCTTTGCCAGGAAGGACATGCTGAAGGAGCACATGCGTGTGCACGACAATGTCCGCGAGTACCTGTGTGCCGAGTGTGGGAAAGGCATGAAGACCAAGCACGCGCTGCGCCACCACATGAAGCTGCACAAGGGCATCAAGGAGTACGAGTGCAAGGAGTGCCACCGCAGGTTCGCGCAGAAGGTCAACATGCTCAAGCACTGCAAGCGGCACACGGGGATTAAAGATTTCATGTGTGAATTGTGTGGGAAGACATTCAGCGAGAGGAACACCATGGAGACCCACAAGCTCATCCACACAGTGGGCAAGCAGTGGACGTGCTCCGTGTGCGACAAGAAGTACGTGACCGAGTACATGCTGCAGAAGCACGTTCAGCTCACACACGACAAGGTGGAGGCGCAGAGCTGCCAGCTGTGCGGGACCAAGGTGTCCACCAGGGCCTCCATGAGCCGACACATGCGGCGCAAGCACCCCGAGGTGCTCGCGGTGAGGATCGATGACCTGGACCACCTCCCGGAGACCACCACCATCGACGCCTCCTCCATTGGCATCGTCCAGCCTGAGCTGACTCTGGAGCAGGAGGATTTGGCCGAAGGGAAGCACGGGAAAGCTGCCAAGCGAAGTCACAAGAGAAAGCAGAAGCCAGAAGAGGAGGCGGGTGCTCCGGTGCCCGAGGACGCCACCTTCAGCGAATACTCAGAGAAAGAGACGGAGTTCACAGGCAGTGTAGGCGACGAGACCAATTCCGCAGTACAGAGCATTCAGCAGGTAGTGGTGACCCTGGGTGACCCAAATGTGACCACACCATCGAGCTCAGTCGGCTTAACCAACATCACCGTGACCCCCATCACCACTGCGGCCGCGACTCAGTTTACCAATCTCCAGCCGGTGGCCGTGGGGCACCTTACCACCCCTGAACGCCAGTTACAGCTGGACAACTCAATCCTGACCGTGACCTTTGATACCGTCAGCGGCTCTGCCATGTTGCACAACCGCCAAAATGACGTCCAGATCCACCCCCAGCCGGAAGCCTCGAACCCACAGTCTGTGGCCCATTTCATCAACCTGACGACCCTGGTCAACTCCATCACGCCCCTGGGGAGCCAGCTTAGTGACCAGCACCCGCTCACGTGGCGGGCAGTGCCCCAGACTGACGTCTTGCCACCCTCGCAGCCGCAGGCACCCCCACAGCAGGCGGCCCAGCCCCAGGTGCAGGCGGAGCAGCAGCAGCAGCAGATGTACAGCTACTGA" )
def test_get_introns(self): XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(XKR8_uid, "grch38") introns = transcript.get_introns() intron_seq = transcript.get_seq_from_pos(introns) self.assertEqual( intron_seq, "GTGAGTGCTTCGCCCCGGGAGGGGAGGAGTGTCGGAGCCCAGCACCTCCGTCAGCTGGGTCACCTGTACAGGTGACACGCCATATGCCGGGAAGGGGACTGGGAGAGGGAACCAAGTCCTGTGGGCGCCTGGCCTACAGGTGAGCGTGCAGCCCTTTACGGAAAGGGAATCCCGGTAGACTGCCTTCATTCTAGCCCTAGCTTTCCTGGCACAGGCGAAGAAACTGAGGCCCAGGGAAGAAAGGGAGGCGCATGGGCTTTGAAGTCGGACCTCTCAGGGATCCACTTCTGGCTTTGCCCCCTCTCGCCTCACTTCTGCATTTCTCTGAGCCTCAGTTTCCTCCTGCGTAGAAAGGAGGTAGTCACCCTGAGACAGGTGTGACGGGCAGGCCTGTTGTGAAGAGTGAGCGAAAGAATGAGAAAGTGCCTCGCACAGTGCCTGGCCTGTAATGGCAGGGGCTGCGGACTCAGTTCAGCATCCCATGTTTCAGCATGGGCAGGGCCTTGGGAAGTCACTGACCTCTCAGTGGGGCTGTTTGGTTGCTGTTCCCATTGGGATGGGGATAGCGCCTGCCCGTTTGGTGAAGATGCAGTGAAATGACATCTGTCCACTGCCCTGGCTCAGAGTGAGCACTCAGCAACCTCAGCTGGCTTCTTGACCTGGGCCTCCCTGGGAGTTTCAGCAGCCCTGACCCCACCACAGCGCTTGCCCCTCACAAAGGCCGCCTCTCACCCTGTCTGCCTGGTTGTATTCTTCCCCCTGAAACTTGGCTTCCCACCCCAGACCCAGCAAGAGGGCAGAGATGGCCTCTGACTCATCCATGCCCATGGAGCCAGCCAGGGCTGGGCATAGGCTGGGTCCTGGAAAATGTGTGTGGATTCTGCTCCTTTTTGGACCTGGTGGAGCCTCGTAGAGATGGGAAAACAAACCCAAGGCTCAGAGGCATGCGACAAAGTCAGGGCAGAGGGTGGTGTGGGTTGGGATGGGGTGGCCAGGGCCAGGATCTGCTCTTGAATCCGTTTTTACAAACTCTTGAGATCTGGCCTTGACAAAGCCACACGGAGTCTCCAGGAGTGGAAGAGAGGAGCTTTGAATGTGGCAGTTTTGCCTGAGGGATTATAGAGACATCAGAAAACCCCGGGTGGGCATGAAGGGGTGCAGTTGTTAAGTCCTGGGCAGGCCTCCATGAGCCGTGAATCTGTAACTACCTTATGCATCTTTGTGGCCAATATTTCTGCTGAGCTTGAGTCAGACAGACTGTACTAGCTTTGGCTTTGGAAATGGGTCTCTGTTCCTGCCTGTGAATTGGCCGAGGCAGGGGTCCCTGCTAGGTCACTGGGGACCATAGGCAAAGGCTCCTGCTGAGGGAGAACCCCAGCCTGTCCTGCCTGCCTGCTCCTCAGTGTGTTCTTGTGTCCTTCCAGGGGAAGTGACAGTACATGTCTGGTGAATGAGCTTGTGATGAGTGAACGGGGTTCTCTCCCAATAGGCAACTGAGAGCAAAGTTCTGGGTGGAGGGTCCTTGGTGCATCCTCCACTTACTCTTCATGCCAGTGGGTACCCCAGACCTGTCTGTCCAAACTCTGGACTCTCTTAACTCCGCCCCAATCTCCATCCTTAACCACTCAGGGCCAGCCTCTTAAATGGGATCCCTCCTTCCAATCTAACCCTCCTCCAGCCCCTCCCCTGTGTGGCCGGGGCAAGGCAGAGTCTGATTCCATCTGGCCTGTGCCCAGAAGTGCCCAAGAGGCAAATGTCCTCTTGCCCACAGGACCCCAGGAGATCTTGGGCACACTAAAGTTTGAGAACTACTGCCTCAGGCAACTTTATAGCATGCCTTTCCAATTCAGGTTTGGATCCAAATCCTCATTCCAGTACTTATTAGCTGCTTATAATTTTTTGTTTGTTTTTTAAAAAGAGGTAGGGTCTGGTCAGGCTTGGTGGCTCATGCCTGTAATCCTAGCAGTCTGGGAGGCTGACGTGGGTGGATCACTTGAGGTCAGGAGTTTGAGACCAGCCTGCTGAACATGGCAAAAGCTCATCTCTACAAAAATTAGCCAGGTGTGGTGGCGCATGCCTGTAATCCCAGCATCCCAGCTACTCTGGAGGCCGAGGCAGGAGAATCGCTTGAACCTGGGAGGTGGAGGTTGCAGTGAGCCGAGTTTGTGCCACTGCACTCTAGCCTGGGCGACAAGCGACAGATGTAGACTCTGTCTCCAAAAAAAAAGAAAAAAAAAAAGAGAGAGAGAGGCAGGGTCTCTGTTGCCTGGGCTGGAGTGCAGTGGCACAATCAATCATGGCTCACAGTGGCCTTGAACTCCTGGGCTCAAGCTGTCCTCCTGCGTCAGCCTCCTGAGTAGCTTGGACTACAGGCTTGTACCACCACGTCCAACTAATTAAAAAAAATTCTTTGTAGAGATGGGGCTTGCTGTGTTGCCCAGGGTGGTCTCAAACTCCTGGCCTCCAGTGATCCTCTTGCCTTGGCCTGTCAAAATGTTGGGATTACAGGCGCGAGCCACTGCACCCAGACCTTATTAGCTTCTTGATCCTGTTTCCCCATCTGTAAAATGGGCTTTTGTGAGAAGTAAACAGGACAAGGTTTGTGATGAGCTTGGGACAGTGCTTAGCCAGCGGGAGTAGAAGGTGTATTGATCCCCATTTTTGCTTTTTTGTTTTTTTTGAGACGGAGTCTTGTTCTGTCGCCAGGCTGGAGTGCAGTGGCACGATCTCGGCTCACTGTAACCTCCGCCTTGCAGATTCAAGAGATTCTCCTGCCTCAGCCTCCTGAGTAGCTGGGACTACAGGCGCGCACCACCACACCCAGCTAATTTTTTGTATTAGTAGAGACGAGGCTTCACCATGTTAGCCAGGATGGTCTCAATCTCCTGAACTCGTGATCAGCCCGCCTCAGACTCCCAAAGTGCTGGGATTACAGGCATGAGCCACCACACCCGGCCTCGATCCTCATTTTACAGATGAAACAAGTTCAGTGAGGTTAGGACATTGCCGAAGGCCCCATAGCATGGATGTGAGGAGACAGGTTGGAGCCTGTGTCCACTCATTAGATGGGTGGGAGGCTGAGGAATTCACAGGACACTAACCTGGCCCTCTGGGCATTTGTGTGTGGTGCCTAGGTGAGTGAAGGCCTGTGGCTGGCCCCCCTGTCGTGGCTTGGTGGGGGGTCTCTCAAATGTTGGAACTGTTTTTAGTCTTTTATAAAGGCTGCTTAGAAAACAGGAGAACAGGCTTTAGTCAGGCAGATCTGGCTTGAAACCTAAAGTCACTCTACAGCTGTTTGAGTTTGGACAAATGCCTTGACCTCTCTGAGTATGTTTGTTCTCATCTGAAATATGGGCTTAAATCCTCCTGCCTCATAAGGTTGATGAAAGGATTAAATGAGGTGATGCAAAGAAAGCCCATTTCCTGGTACATAAGTTCCTGGTACAGAGTCTCACTCTGTCATCGCCCGTAGTGGAGTACAGCAGCCTGATCATGGCTCACTGTAGCCTCCACCTCCCAGGCTCAAGTGATCCTCCTGTCTCAGCCTCCTGAGTAGCTGGGACTACAAGTGTGTATCACCATGCTGGCTAATTTTTCTTTCTTTTTTTTTTTTTTTTTTTTGTAGAGACGAGGTCCCACTTTGTTACCCAGGCTGGTCTTGAACTCCTGAGCTCAAGTAACCTCCTACCTCAGCCTCCTAAGGTGCTGGGATTACAGGTGTCGCCCACTGTGCCTGGCCCACAAGTCTTAATTGTAATTTTTATAATTTTGAAGATAATGAAGTGTGTAAGGTGCCTGATACAGCATAGGTAACTTTTTAGTTAAGAAACAATTTCATACGTTGGGAGGCCAAGGTGCACAGGTCGCTTGAGGCCAGAGTTGGAGACCATCCTGGGTAACATAGTGAGACCTCATCTCTTCAAAATTTTAAAAGAGAAACAAGAAACAATATATTGAATGCCTTCATCCAGTCAGGTTTTCATTGTGCATCTCTTCTGTGCCTGTTACTGTGCTGGGGACACAGCAGTGAACAAGATGAACCCAGCCCCTGCCCTGCCAGGATGATAGACTAAAACAAGTAGCTACGGTTGAGTGACTGGAAAAGGGAGAGGCAGGGAGCAGAGGATCACAGGGCCCCCTAAGCATGGGTGAAGTTTACAGTGAGGAGCTTTGGGAGGGTTTTTGCATGAAAGGAAAGTGACTTGCCCATTTCCACAGACCTGGACAGTGGCCAAGCTAAAGAGGGCCCCCACTCACATCCGACTCAGGGTCCAAGCCTTCCCCTTTGCCTTCCTCCACCGCTGCCATAAATGCCACAGCCTCTCAAGAAACCAGTCCTCACTCTACCGTCACTCGCTGTGTGACCTGGAGAGCCTTCCTGTGGAAGATGGAGGTTGGACTCGATCTCCAAGGGCCCTTTCGTCTTGCTAGTCTGAGTCTATATATTGATTGAAAAAACAATAATAGCGGCTGTCACAATCGAGTGCCAGCTATTAGCCAGGCCCTGTGGGAAGCACTTACAGTCATCATTGCTCATGTTCACAGCAGCCCTGTAGGTTTGTGCTATATTGATCTTCATTTTTAAAGAGGTGCAGAAAGGTGAGTGACTTGCCCTGGGTTACTGGGCACTCACTGGGCACACGTCTTTGTCTGTTGAGGGTTGGGGGTGTCTAGAACCAGGGCCAAGTGCAGACAGTCTGCACTGTGAGTGTGGCAGGGGGTAAGGGGGCGAGACAGATTTTCCCTACTTTTTATTTAGCAAACATCTCTTTCGCTGCTGTTATGTGCCAGGTACTGGGCTGCTGGGGGATCCCAAGTGAGCAGAGTCTGTTTTCTACCCTCGAGGAGCCCAGAGATAAGGAAATAGATAATTACTGTGTGATGAGACTCCAGACAGAGGTGGGTGGCATGTTACAGGGATACCTGACACAGCTGAGTGGGTGGCATGGGGTCAGGGTGGGTGACTCCCGGGGCTCTTCAAGCTGGGGCCTGCGGGGTAATGGAGGAGTAGGCCGGGGAAGTGGGGCCTGTGCTTCTGGCGACCTAACATCCTGGGCAGAGCTTGTCAAGGTCACGGAAGGTGGCATGCTGGGCAAACTGGAAGAACATCAGCCCTGCTGAGACCTGGGCAAGGCTAATGAGCACAGATCTGTTTCCAGGCTAGGAGTGGGTTCTGGGCGCCTAATAGGTTCCCAGTAAACATCTGTCGAATGACTGCGGTGGACGGGGACAGGGGAGGAAGCAGTCGGGAGACGTGCCGGTGCCACTTCCATCCCTCCCTGGAGGCCCTTGTGCTTCTGCTCCAGGATTGGCAACCAGGAGGTGGGATAGGACCCCTGTTGTAAACTTCTGGATCTTGGAAAATCAAGGTTAGGGGTCAGTCCGATGGCCTCTGGTCTTGGAGGGGAGGGGAGGGGAGTGGGGAGACCTTCTGTCCACACAGCAGGGACATCTCTCCTGGCCCTGAGGGCAGCTTTAGCCAGAGCCTGTTGCCACCCCATGGGATTTTCTACTCCCTTTTTGAGACTAAGAAAGACGGAACTGAGACTGTTGATTTTTAGACACAAGGAAGGCTTGTGTTCTTCCCAGAAAGAAAGGGTTATGGGGCCCTGGAAGATGCCCAGGATGCAGCCAAGGCCCAGGGGTGCTGAGTGCTGGGTGGGCCACAGGTCACATCCTCTCATCTTTGACAAATACCACCCGGATAGCACCTACGCAGCAAAGCGCTGTGGTGAGGGGCAGGCTCTATATTAGGAGTCATAGCTTTGTTTTTGGTTGTGGGAACTCACTGGGTCTTCTCTAGCTGCAGATTTGCCTTCAACAAACGAGGGATTCTAATACCTACCCCAGGGTTGCTGGGAGGGCCCCCACGGTACCTGTGACCGCTGGGGAGTGCCAAGCAGGCTGGCCCCAGGACTCACTGTTCCCTCCTACTCTTTGCAG" .upper())
def test_get_seq( self ): ########################################################################3 XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(XKR8_uid, "grch38") seq = transcript.get_seq() self.assertEqual( seq, "GAGGGCTGCGCCCACCTCCTTCCTGCCTCGGCAACCCCGGGCCCTGAGGGCAGGCCCCAACCGCGGAGGAGCAGGAGAGGGCGGAGGCCGGCGGGCCATGCCCTGGTCGTCCCGCGGCGCCCTCCTTCGGGACCTGGTCCTGGGCGTGCTGGGCACCGCCGCCTTCCTGCTCGACCTGGGCACCGACCTGTGGGCCGCCGTCCAGTATGCGCTCGGCGGCCGCTACCTGTGGGCGGCGCTGGTGCTGGCGCTGCTGGGCCTGGCCTCCGTGGCGCTGCAGCTCTTCAGCTGGCTCTGGCTGCGCGCTGACCCTGCCGGCCTGCACGGGTCGCAGCCCCCGCGCCGCTGCCTGGCGCTGCTGCATCTCCTGCAGCTGGGTTACCTGTACAGGTGAGTGCTTCGCCCCGGGAGGGGAGGAGTGTCGGAGCCCAGCACCTCCGTCAGCTGGGTCACCTGTACAGGTGACACGCCATATGCCGGGAAGGGGACTGGGAGAGGGAACCAAGTCCTGTGGGCGCCTGGCCTACAGGTGAGCGTGCAGCCCTTTACGGAAAGGGAATCCCGGTAGACTGCCTTCATTCTAGCCCTAGCTTTCCTGGCACAGGCGAAGAAACTGAGGCCCAGGGAAGAAAGGGAGGCGCATGGGCTTTGAAGTCGGACCTCTCAGGGATCCACTTCTGGCTTTGCCCCCTCTCGCCTCACTTCTGCATTTCTCTGAGCCTCAGTTTCCTCCTGCGTAGAAAGGAGGTAGTCACCCTGAGACAGGTGTGACGGGCAGGCCTGTTGTGAAGAGTGAGCGAAAGAATGAGAAAGTGCCTCGCACAGTGCCTGGCCTGTAATGGCAGGGGCTGCGGACTCAGTTCAGCATCCCATGTTTCAGCATGGGCAGGGCCTTGGGAAGTCACTGACCTCTCAGTGGGGCTGTTTGGTTGCTGTTCCCATTGGGATGGGGATAGCGCCTGCCCGTTTGGTGAAGATGCAGTGAAATGACATCTGTCCACTGCCCTGGCTCAGAGTGAGCACTCAGCAACCTCAGCTGGCTTCTTGACCTGGGCCTCCCTGGGAGTTTCAGCAGCCCTGACCCCACCACAGCGCTTGCCCCTCACAAAGGCCGCCTCTCACCCTGTCTGCCTGGTTGTATTCTTCCCCCTGAAACTTGGCTTCCCACCCCAGACCCAGCAAGAGGGCAGAGATGGCCTCTGACTCATCCATGCCCATGGAGCCAGCCAGGGCTGGGCATAGGCTGGGTCCTGGAAAATGTGTGTGGATTCTGCTCCTTTTTGGACCTGGTGGAGCCTCGTAGAGATGGGAAAACAAACCCAAGGCTCAGAGGCATGCGACAAAGTCAGGGCAGAGGGTGGTGTGGGTTGGGATGGGGTGGCCAGGGCCAGGATCTGCTCTTGAATCCGTTTTTACAAACTCTTGAGATCTGGCCTTGACAAAGCCACACGGAGTCTCCAGGAGTGGAAGAGAGGAGCTTTGAATGTGGCAGTTTTGCCTGAGGGATTATAGAGACATCAGAAAACCCCGGGTGGGCATGAAGGGGTGCAGTTGTTAAGTCCTGGGCAGGCCTCCATGAGCCGTGAATCTGTAACTACCTTATGCATCTTTGTGGCCAATATTTCTGCTGAGCTTGAGTCAGACAGACTGTACTAGCTTTGGCTTTGGAAATGGGTCTCTGTTCCTGCCTGTGAATTGGCCGAGGCAGGGGTCCCTGCTAGGTCACTGGGGACCATAGGCAAAGGCTCCTGCTGAGGGAGAACCCCAGCCTGTCCTGCCTGCCTGCTCCTCAGTGTGTTCTTGTGTCCTTCCAGGGGAAGTGACAGTACATGTCTGGTGAATGAGCTTGTGATGAGTGAACGGGGTTCTCTCCCAATAGGCAACTGAGAGCAAAGTTCTGGGTGGAGGGTCCTTGGTGCATCCTCCACTTACTCTTCATGCCAGTGGGTACCCCAGACCTGTCTGTCCAAACTCTGGACTCTCTTAACTCCGCCCCAATCTCCATCCTTAACCACTCAGGGCCAGCCTCTTAAATGGGATCCCTCCTTCCAATCTAACCCTCCTCCAGCCCCTCCCCTGTGTGGCCGGGGCAAGGCAGAGTCTGATTCCATCTGGCCTGTGCCCAGAAGTGCCCAAGAGGCAAATGTCCTCTTGCCCACAGGACCCCAGGAGATCTTGGGCACACTAAAGTTTGAGAACTACTGCCTCAGGCAACTTTATAGCATGCCTTTCCAATTCAGGTTTGGATCCAAATCCTCATTCCAGTACTTATTAGCTGCTTATAATTTTTTGTTTGTTTTTTAAAAAGAGGTAGGGTCTGGTCAGGCTTGGTGGCTCATGCCTGTAATCCTAGCAGTCTGGGAGGCTGACGTGGGTGGATCACTTGAGGTCAGGAGTTTGAGACCAGCCTGCTGAACATGGCAAAAGCTCATCTCTACAAAAATTAGCCAGGTGTGGTGGCGCATGCCTGTAATCCCAGCATCCCAGCTACTCTGGAGGCCGAGGCAGGAGAATCGCTTGAACCTGGGAGGTGGAGGTTGCAGTGAGCCGAGTTTGTGCCACTGCACTCTAGCCTGGGCGACAAGCGACAGATGTAGACTCTGTCTCCAAAAAAAAAGAAAAAAAAAAAGAGAGAGAGAGGCAGGGTCTCTGTTGCCTGGGCTGGAGTGCAGTGGCACAATCAATCATGGCTCACAGTGGCCTTGAACTCCTGGGCTCAAGCTGTCCTCCTGCGTCAGCCTCCTGAGTAGCTTGGACTACAGGCTTGTACCACCACGTCCAACTAATTAAAAAAAATTCTTTGTAGAGATGGGGCTTGCTGTGTTGCCCAGGGTGGTCTCAAACTCCTGGCCTCCAGTGATCCTCTTGCCTTGGCCTGTCAAAATGTTGGGATTACAGGCGCGAGCCACTGCACCCAGACCTTATTAGCTTCTTGATCCTGTTTCCCCATCTGTAAAATGGGCTTTTGTGAGAAGTAAACAGGACAAGGTTTGTGATGAGCTTGGGACAGTGCTTAGCCAGCGGGAGTAGAAGGTGTATTGATCCCCATTTTTGCTTTTTTGTTTTTTTTGAGACGGAGTCTTGTTCTGTCGCCAGGCTGGAGTGCAGTGGCACGATCTCGGCTCACTGTAACCTCCGCCTTGCAGATTCAAGAGATTCTCCTGCCTCAGCCTCCTGAGTAGCTGGGACTACAGGCGCGCACCACCACACCCAGCTAATTTTTTGTATTAGTAGAGACGAGGCTTCACCATGTTAGCCAGGATGGTCTCAATCTCCTGAACTCGTGATCAGCCCGCCTCAGACTCCCAAAGTGCTGGGATTACAGGCATGAGCCACCACACCCGGCCTCGATCCTCATTTTACAGATGAAACAAGTTCAGTGAGGTTAGGACATTGCCGAAGGCCCCATAGCATGGATGTGAGGAGACAGGTTGGAGCCTGTGTCCACTCATTAGATGGGTGGGAGGCTGAGGAATTCACAGGACACTAACCTGGCCCTCTGGGCATTTGTGTGTGGTGCCTAGGTGCGTGCAGGAGCTGCGGCAGGGGCTGCTGGTGTGGCAGCAGGAGGAGCCCTCTGAGTTTGACTTGGCCTACGCCGACTTCCTCGCCCTGGACATCAGCATGCTGCGGCTCTTCGAGACCTTCTTGGAGACGGCACCACAGCTCACGCTGGTGCTGGCCATCATGCTGCAGAGTGGCCGGGCTGAGTACTACCAGTGTGAGTGAAGGCCTGTGGCTGGCCCCCCTGTCGTGGCTTGGTGGGGGGTCTCTCAAATGTTGGAACTGTTTTTAGTCTTTTATAAAGGCTGCTTAGAAAACAGGAGAACAGGCTTTAGTCAGGCAGATCTGGCTTGAAACCTAAAGTCACTCTACAGCTGTTTGAGTTTGGACAAATGCCTTGACCTCTCTGAGTATGTTTGTTCTCATCTGAAATATGGGCTTAAATCCTCCTGCCTCATAAGGTTGATGAAAGGATTAAATGAGGTGATGCAAAGAAAGCCCATTTCCTGGTACATAAGTTCCTGGTACAGAGTCTCACTCTGTCATCGCCCGTAGTGGAGTACAGCAGCCTGATCATGGCTCACTGTAGCCTCCACCTCCCAGGCTCAAGTGATCCTCCTGTCTCAGCCTCCTGAGTAGCTGGGACTACAAGTGTGTATCACCATGCTGGCTAATTTTTCTTTCTTTTTTTTTTTTTTTTTTTTGTAGAGACGAGGTCCCACTTTGTTACCCAGGCTGGTCTTGAACTCCTGAGCTCAAGTAACCTCCTACCTCAGCCTCCTAAGGTGCTGGGATTACAGGTGTCGCCCACTGTGCCTGGCCCACAAGTCTTAATTGTAATTTTTATAATTTTGAAGATAATGAAGTGTGTAAGGTGCCTGATACAGCATAGGTAACTTTTTAGTTAAGAAACAATTTCATACGTTGGGAGGCCAAGGTGCACAGGTCGCTTGAGGCCAGAGTTGGAGACCATCCTGGGTAACATAGTGAGACCTCATCTCTTCAAAATTTTAAAAGAGAAACAAGAAACAATATATTGAATGCCTTCATCCAGTCAGGTTTTCATTGTGCATCTCTTCTGTGCCTGTTACTGTGCTGGGGACACAGCAGTGAACAAGATGAACCCAGCCCCTGCCCTGCCAGGATGATAGACTAAAACAAGTAGCTACGGTTGAGTGACTGGAAAAGGGAGAGGCAGGGAGCAGAGGATCACAGGGCCCCCTAAGCATGGGTGAAGTTTACAGTGAGGAGCTTTGGGAGGGTTTTTGCATGAAAGGAAAGTGACTTGCCCATTTCCACAGACCTGGACAGTGGCCAAGCTAAAGAGGGCCCCCACTCACATCCGACTCAGGGTCCAAGCCTTCCCCTTTGCCTTCCTCCACCGCTGCCATAAATGCCACAGCCTCTCAAGAAACCAGTCCTCACTCTACCGTCACTCGCTGTGTGACCTGGAGAGCCTTCCTGTGGAAGATGGAGGTTGGACTCGATCTCCAAGGGCCCTTTCGTCTTGCTAGTCTGAGTCTATATATTGATTGAAAAAACAATAATAGCGGCTGTCACAATCGAGTGCCAGCTATTAGCCAGGCCCTGTGGGAAGCACTTACAGTCATCATTGCTCATGTTCACAGCAGCCCTGTAGGTTTGTGCTATATTGATCTTCATTTTTAAAGAGGTGCAGAAAGGTGAGTGACTTGCCCTGGGTTACTGGGCACTCACTGGGCACACGTCTTTGTCTGTTGAGGGTTGGGGGTGTCTAGAACCAGGGCCAAGTGCAGACAGTCTGCACTGTGAGTGTGGCAGGGGGTAAGGGGGCGAGACAGATTTTCCCTACTTTTTATTTAGCAAACATCTCTTTCGCTGCTGTTATGTGCCAGGTACTGGGCTGCTGGGGGATCCCAAGTGAGCAGAGTCTGTTTTCTACCCTCGAGGAGCCCAGAGATAAGGAAATAGATAATTACTGTGTGATGAGACTCCAGACAGAGGTGGGTGGCATGTTACAGGGATACCTGACACAGCTGAGTGGGTGGCATGGGGTCAGGGTGGGTGACTCCCGGGGCTCTTCAAGCTGGGGCCTGCGGGGTAATGGAGGAGTAGGCCGGGGAAGTGGGGCCTGTGCTTCTGGCGACCTAACATCCTGGGCAGAGCTTGTCAAGGTCACGGAAGGTGGCATGCTGGGCAAACTGGAAGAACATCAGCCCTGCTGAGACCTGGGCAAGGCTAATGAGCACAGATCTGTTTCCAGGCTAGGAGTGGGTTCTGGGCGCCTAATAGGTTCCCAGTAAACATCTGTCGAATGACTGCGGTGGACGGGGACAGGGGAGGAAGCAGTCGGGAGACGTGCCGGTGCCACTTCCATCCCTCCCTGGAGGCCCTTGTGCTTCTGCTCCAGGATTGGCAACCAGGAGGTGGGATAGGACCCCTGTTGTAAACTTCTGGATCTTGGAAAATCAAGGTTAGGGGTCAGTCCGATGGCCTCTGGTCTTGGAGGGGAGGGGAGGGGAGTGGGGAGACCTTCTGTCCACACAGCAGGGACATCTCTCCTGGCCCTGAGGGCAGCTTTAGCCAGAGCCTGTTGCCACCCCATGGGATTTTCTACTCCCTTTTTGAGACTAAGAAAGACGGAACTGAGACTGTTGATTTTTAGACACAAGGAAGGCTTGTGTTCTTCCCAGAAAGAAAGGGTTATGGGGCCCTGGAAGATGCCCAGGATGCAGCCAAGGCCCAGGGGTGCTGAGTGCTGGGTGGGCCACAGGTCACATCCTCTCATCTTTGACAAATACCACCCGGATAGCACCTACGCAGCAAAGCGCTGTGGTGAGGGGCAGGCTCTATATTAGGAGTCATAGCTTTGTTTTTGGTTGTGGGAACTCACTGGGTCTTCTCTAGCTGCAGATTTGCCTTCAACAAACGAGGGATTCTAATACCTACCCCAGGGTTGCTGGGAGGGCCCCCACGGTACCTGTGACCGCTGGGGAGTGCCAAGCAGGCTGGCCCCAGGACTCACTGTTCCCTCCTACTCTTTGCAGGGGTTGGCATCTGCACATCCTTCCTGGGCATCTCGTGGGCACTGCTCGACTACCACCGGGCCTTGCGCACCTGCCTCCCCTCCAAGCCGCTCCTGGGCCTGGGCTCCTCCGTGATCTACTTCCTGTGGAACCTGCTGCTGCTGTGGCCCCGAGTCCTGGCTGTGGCCCTGTTCTCAGCCCTCTTCCCCAGCTATGTGGCCCTGCACTTCCTGGGCCTGTGGCTGGTACTGCTGCTCTGGGTCTGGCTTCAGGGCACAGACTTCATGCCGGACCCCAGCTCCGAGTGGCTGTACCGGGTGACGGTGGCCACCATCCTCTATTTCTCCTGGTTCAACGTGGCTGAGGGCCGCACCCGAGGCCGGGCCATCATCCACTTCGCCTTCCTCCTGAGTGACAGCATTCTCCTGGTGGCCACCTGGGTGACTCATAGCTCCTGGCTGCCCAGCGGGATTCCACTGCAGCTGTGGCTGCCTGTGGGATGCGGCTGCTTCTTTCTGGGCCTGGCTCTGCGGCTTGTGTACTACCACTGGCTGCACCCTAGCTGCTGCTGGAAGCCCGACCCTGACCAGGTAGACGGGGCCCGGAGTCTGCTTTCTCCAGAGGGGTATCAGCTGCCTCAGAACAGGCGCATGACCCATTTAGCACAGAAGTTTTTCCCCAAGGCTAAGGATGAGGCTGCTTCGCCAGTGAAGGGATAGGTGAACGGCGTCCTTTGAAGCAGGATCAGACCCAGCCAGCAGAGATGGAGAGTGACTCTGTTGGCAGAAGGCAGGCGAGGATAAGCTAACGATGCTGCTGTGGCCTCTATGCACTCAGCAAGAGCGGGACGCCTGTGCTGGGCCGGGCACCAGGGATGGTGCTGAGTCGGGCAGAGGCCTCCTTTCAAGGAGTTCACAGTGAACAAGATGAGAAGGGCTGGGCCCTGGAGGGTCAAGAGCCCCAATTATGTACAAGACACTTTGGGAGGAAAGAAGACTACCTTTTCCCCCTGCCATTGGTATAGCTGGTGCCCCAAAACTTCCACCTCCCTCCCTGGCTACCTCTAAAATGACTGGTATAGGTGCTGCCCCACCCCTTAGCTCCCCTATCCTGGGCTAGGAGGCCACAGGGGCTGTCCTCTAGAATTCTTCCTTCCCTCCCCCACACCATTCATTCAATTCATGAAACAAATCTTTGCCAAGAGCAGTTTATGTGCCAGGAACATCATTCTGTCCTTGCAACCTGGAACAAGACCAGCTACCAGCCTAGCTTCATCCGCTACTTGCACCAACCAGTCCCGGGTTAGATCCCAAATGCTAGAAGCCAGGGATGCCCAACTCTGGGTGGCCCCAGTCAGAACCTCTGGGATCTCAGTGAAGCTGGCCTGGCCTCTGCTCCTGCTCTCAAGGGGCTGCTTTTCAACCAAGAGCCTTGTGAGCCTGGTCTGAGCCTTGCACAGCCACTGAGTATTTTTTTTGCCTTAGCCAGTGTACCTCCTACCTCAGTCTATGTGAGAGGAAGAGAATGTGTGTGCCTGTGGGTCTCTACAAGTGACAGATGTGTTGTTTTCAACAGTATTATTAGGTTATGAATAAAGCCTCATGAAATCCTC" .upper())
class InsersionMethodTesting(unittest.TestCase): time.sleep(2) mei_any = { 'TYPE': 'MEI', 'REGION': 'INTRONIC', 'IMPACT': { "ELEMENT": "ALU", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } mei_spec = { 'TYPE': 'MEI', 'REGION': 'CODING', 'IMPACT': { "ELEMENT": "ALU", "START": 129814000 }, "ZYGOSITY": "HETEROZYGOUS" } SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"] positive_transcript = Transcript(SOX9_uid, "grch38") TOR1A_uid = get_all_transcripts("TOR1A", "grch38")[0]["qualifiers"]["uid"] negative_transcript = Transcript(TOR1A_uid, "grch38") # test 4 def test_get_insertion_any(self): mei = MEI(self.mei_any, self.positive_transcript) vcf_row = mei.get_vcf_row() self.assertEqual(vcf_row["alt"], '<INS:MEI:ALU>') self.assertRegex(vcf_row["info"], re.compile('.*SVLEN=282.*')) # test 5 def test_get_insertion_spec(self): mei = MEI(self.mei_spec, self.negative_transcript) vcf_row = mei.get_vcf_row() self.assertEqual(vcf_row["pos"], '129814000') self.assertEqual(vcf_row["alt"], '<INS:MEI:ALU>') self.assertEqual(vcf_row["info"], 'SVTYPE=INS;END=129814282;SVLEN=282;') self.assertEqual(vcf_row['chrom'], "9")
class MutationMethods(unittest.TestCase): time.sleep(1) XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(XKR8_uid, "grch38") snv = { "TYPE": "SNV", "REGION": "INTRONIC", "IMPACT": { "SNV_TYPE": "A", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, transcript) # test 3 def test_nonsense_exists(self): self.assertEqual(self.snv.nonsense_mutation("TAT", 2), "A") # test 4 def test_nonsense_not_exists(self): self.assertFalse(self.snv.nonsense_mutation("TAT", 1)) # test 5 def test_misssense_false(self): self.assertFalse(self.snv.missense_mutation("TAT", 2)) # test 6 def test_misssense_exists(self): self.assertIn(self.snv.missense_mutation("CAC", 2), ["G", "A"]) # test 7 def test_synonymous_exists(self): self.assertFalse(self.snv.synonymous_mutation("TGG", 2)) # test 8 def test_synonymous_false(self): self.assertEqual(self.snv.synonymous_mutation("CAA", 2), "G") # test 9 def test_any_mutation(self): self.assertIn(self.snv.any_mutation("CAA", 2), ["G", "C", "T"]) # test 10 def test_stoploss(self): self.assertIn(self.snv.stoploss_mutation("TAG", 2), ["C", "T"]) # test 11 def test_stoploss_not_valid(self): self.assertFalse(self.snv.stoploss_mutation("GGA", 2))
class NonCodingSNV(unittest.TestCase): time.sleep(1) SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"] positive_transcript = Transcript(SOX9_uid, "grch38") # test 12 def test_basic_non_coding(self): snv = { "TYPE": "SNV", "REGION": "INTRONIC", "IMPACT": { "SNV_TYPE": "A", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.positive_transcript) row = snv.get_vcf_row() self.assertEqual(row["alt"], "A") # test 13 def test_basic_non_coding_exact(self): snv = { "TYPE": "SNV", "REGION": "INTRONIC", "IMPACT": { "SNV_TYPE": "A", "START": 72122000 }, "ZYGOSITY": "HETEROZYGOUS" } row = SNV(snv, self.positive_transcript).get_vcf_row() self.assertEqual(row["pos"], "72122000") self.assertEqual(row["ref"], "C") self.assertEqual(row["alt"], "A") # test 14 def test_non_coding_incorrect_impact(self): snv = { "TYPE": "SNV", "REGION": "INTRONIC", "IMPACT": { "SNV_TYPE": "MISSENSE", "START": 72121999 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): snv = SNV(snv, self.positive_transcript)
def test_raises_length_greater_than_location(self): SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"] SOX18 = Transcript(SOX18_uid, "grch38") indel = { 'TYPE': 'INDEL', 'REGION': 'INTRONIC', 'IMPACT': { "INDEL_AMOUNT": -150, "START": 64049150 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): indel = Indel(indel, SOX18)
def test_location_0(self): time.sleep(2) SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"] SOX18 = Transcript(SOX18_uid, "grch38") mei = { "TYPE": "MEI", "REGION": "INTRONIC", "IMPACT": { "ELEMENT": "ALU", "START": 0 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): MEI(mei, SOX18).get_vcf_row()
def test_type_value_MEI(self): time.sleep(2) XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(XKR8_uid, "grch38") mei = { "TYPE": "SNV", "REGION": "INTRONIC", "IMPACT": { "ELEMENT": "ALU", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): MEI(mei, transcript)
def test_get_utrs_negative_strand(self): TOR1A_uid = get_all_transcripts("TOR1A", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(TOR1A_uid, "grch38") both_utr = transcript.get_utr("both") both_utr = transcript.get_seq_from_pos(both_utr) self.assertEqual( both_utr, "GCACCGGTTCGCGGTCGGCGCGAGAACAAGCAGGGTGGCGCGGGTCCGGGCCAGTCATGATTGGCAGCCGGAGTCACTGCCTGGAGTTGGAAAAGAAACAACACTCAGTCCTTCCACACTTCCACCCCCAGCTCCTTTCCCTGGAAGAGGAATCCAGTGAATGTTCCTGTTTGATGTGACAGGAATTCTCCCTGGCATTGTTTCCACCCCCTGGTGCCTGCAGGCCACCCAGGGACCACGGGCGAGGACGTGAAGCCTCCCGAACACGCACAGAAGGAAGGAGCCAGCTCCCAGCCCACTCATCGCAGGGCTCATGATTTTTTACAAATTATGTTTTAATTCCAAGTGTTTCTGTTTCAAGGAAGGATGAATAAGTTTTATTGAAAATGTGGTAACTTTATTTAAAATGATTTTTAACATTATGAGAGACTGCTCAGATTCTAAGTTGTTGGCCTTGTGTGTGTGTTTTTTTTTAAGTTCTCATCATTATTACATAGACTGTGATGTATCTTTACTGGAAATGAGCCCAAGCACACATGCATGGCATTTGTTCCACAGGAGGGCATCCCTGGGGATGTGGCTGGAGCATGAGCCAGCTCTGTCCCAGGATGGTCCCAGCGGATGCTGCCAGGGGCAGTGAAGTGTTTAGGTGAAGGACAAGTAGGTAAGAGGACGCCTTCAGGCACCACAGATAAGCCTGAAACAGCCTCTCCAAGGGTTTTCACCTTAGCAACAATGGGAGCTGTGGGAGTGATTTTGGCCACACTGTCAACATTTGTTAGAACCAGTCTTTTGAAAGAAAAGTATTTCCAACTTGTCACTTGCCAGTCACTCCGTTTTGCAAAAGGTGGCCCTTCACTGTCCATTCCAAATAGCCCACACGTGCTCTCTGCTGGATTCTAAATTATGTGAATTTTGCCATATTAAATCTTCCTCATTTATACTATTATTTGTTACGTTCAATCAGAATCCCCGAAACCTCCTATAAAGCTTAGCTGCCCCTTCTGAGGATGCTGAGAACGGTGTCTTTCTTTATAAATGCAAATGGCTACCGTTTTACAATAAAATTTTGCATGTGCCA" ) prime_5 = transcript.get_utr("5_prime") prime_5 = transcript.get_seq_from_pos(prime_5) self.assertEqual( prime_5, "GCACCGGTTCGCGGTCGGCGCGAGAACAAGCAGGGTGGCGCGGGTCCGGGC") prime_3 = transcript.get_utr("3_prime") prime_3 = transcript.get_seq_from_pos(prime_3) self.assertEqual( prime_3, "CAGTCATGATTGGCAGCCGGAGTCACTGCCTGGAGTTGGAAAAGAAACAACACTCAGTCCTTCCACACTTCCACCCCCAGCTCCTTTCCCTGGAAGAGGAATCCAGTGAATGTTCCTGTTTGATGTGACAGGAATTCTCCCTGGCATTGTTTCCACCCCCTGGTGCCTGCAGGCCACCCAGGGACCACGGGCGAGGACGTGAAGCCTCCCGAACACGCACAGAAGGAAGGAGCCAGCTCCCAGCCCACTCATCGCAGGGCTCATGATTTTTTACAAATTATGTTTTAATTCCAAGTGTTTCTGTTTCAAGGAAGGATGAATAAGTTTTATTGAAAATGTGGTAACTTTATTTAAAATGATTTTTAACATTATGAGAGACTGCTCAGATTCTAAGTTGTTGGCCTTGTGTGTGTGTTTTTTTTTAAGTTCTCATCATTATTACATAGACTGTGATGTATCTTTACTGGAAATGAGCCCAAGCACACATGCATGGCATTTGTTCCACAGGAGGGCATCCCTGGGGATGTGGCTGGAGCATGAGCCAGCTCTGTCCCAGGATGGTCCCAGCGGATGCTGCCAGGGGCAGTGAAGTGTTTAGGTGAAGGACAAGTAGGTAAGAGGACGCCTTCAGGCACCACAGATAAGCCTGAAACAGCCTCTCCAAGGGTTTTCACCTTAGCAACAATGGGAGCTGTGGGAGTGATTTTGGCCACACTGTCAACATTTGTTAGAACCAGTCTTTTGAAAGAAAAGTATTTCCAACTTGTCACTTGCCAGTCACTCCGTTTTGCAAAAGGTGGCCCTTCACTGTCCATTCCAAATAGCCCACACGTGCTCTCTGCTGGATTCTAAATTATGTGAATTTTGCCATATTAAATCTTCCTCATTTATACTATTATTTGTTACGTTCAATCAGAATCCCCGAAACCTCCTATAAAGCTTAGCTGCCCCTTCTGAGGATGCTGAGAACGGTGTCTTTCTTTATAAATGCAAATGGCTACCGTTTTACAATAAAATTTTGCATGTGCCA" )
class VariantMethodTests(unittest.TestCase): XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(XKR8_uid, "grch38") good_var = { "TYPE": "INDEL", "REGION": "INTRONIC", "IMPACT": { "INDEL_AMOUNT": -100, "LOCATION": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } good_var = Variant(good_var, transcript) def test_get_type(self): self.assertEqual(self.good_var.get_type(), "INDEL") def test_get_region(self): self.assertEqual(self.good_var.get_region(), "INTRONIC")
def __init__(self, variants_file): """ creates variants object which has gene, inheritance, var1, var2 """ if type(variants_file) != dict: f = open(variants_file) variants_json = json.load(f) f.close() else: variants_json = variants_file try: self.transcript = Transcript(variants_json["GENE_UID"], variants_json["GENOME"]) self.var1 = self.make_variant(variants_json["VAR1"], self.transcript) self.var2 = self.make_variant(variants_json["VAR2"], self.transcript) self.sex = variants_json["SEX"] self.check_sex_zygosity() except Exception as e: raise Exception(e)
def test_normal_gene(self): transcript = Transcript(5, 'grch38') print(transcript)
class DirectedSNVCodingRegionTestsPositive(unittest.TestCase): time.sleep(1) SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"] positive_transcript = Transcript(SOX9_uid, "grch38") # test 15 def test_directed_SNV_exists_single_replacement(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "G", "START": 72121500 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.positive_transcript).get_vcf_row() self.assertEqual(snv['ref'], "T") self.assertEqual(snv['alt'], "G") # test 16 def test_directed_SNV_exists_nonsense(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "NONSENSE", "START": 72121513 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.positive_transcript).get_vcf_row() self.assertEqual(snv['ref'], "C") self.assertEqual(snv['alt'], "A") # test 17 def test_directed_SNV_exists_missense(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "MISSENSE", "START": 72121517 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.positive_transcript) # test 18 def test_directed_SNV_exists_SYNONYMOUS(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "SYNONYMOUS", "START": 72121517 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.positive_transcript).get_vcf_row() self.assertEqual(snv['ref'], "C") self.assertEqual(snv['alt'], "T") # test 19 def test_directed_SNV_false(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "NONSENSE", "START": 72121517 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(Exception): snv = SNV(snv, self.positive_transcript) # test 20 def test_directed_SNV_stoploss_false(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "STOPLOSS", "START": 72124380 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(Exception): snv = SNV(snv, self.positive_transcript) # test 21 def test_directed_SNV_stoploss_exists(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "STOPLOSS", "START": 72124385 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.positive_transcript).get_vcf_row() self.assertEqual(snv['ref'], "T") self.assertIn(snv['alt'], ["A", "G", "C"]) self.assertEqual(snv['pos'], "72124385") # test 22 def test_undirected_SNV_stoploss_exists(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "STOPLOSS", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.positive_transcript).get_vcf_row() self.assertIn(snv['pos'], ["72124385", "72124386", "72124387"])
class DirectedSNVCodingRegionTestsNegative(unittest.TestCase): time.sleep(1) SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"] negative_transcript = Transcript(SOX18_uid, "grch38") # test 23 def test_directed_SNV_exists_single_replacement(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "G", "START": 64048520 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.negative_transcript).get_vcf_row() self.assertEqual(snv['ref'], "C") self.assertEqual(snv['alt'], "G") # test 24 def test_directed_SNV_exists_nonsense(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "NONSENSE", "START": 64048519 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.negative_transcript).get_vcf_row() self.assertEqual(snv['ref'], "C") self.assertEqual(snv['alt'], "A") # test 25 def test_directed_SNV_not_exists_missense(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "MISSENSE", "START": 64048502 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(Exception): snv = SNV(snv, self.negative_transcript) # test 26 def test_directed_SNV_exists_SYNONYMOUS(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "SYNONYMOUS", "START": 64048502 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.negative_transcript).get_vcf_row() self.assertEqual(snv['ref'], "C") self.assertIn(snv['alt'], ["A", "G", "T"]) # test 27 def test_directed_SNV_stoploss_false(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "STOPLOSS", "START": 64048164 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(Exception): snv = SNV(snv, self.negative_transcript) # test 28 def test_directed_SNV_stoploss_exists(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "STOPLOSS", "START": 64048166 }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.negative_transcript).get_vcf_row() self.assertEqual(snv['ref'], "C") self.assertIn(snv['alt'], ["A", "G"]) self.assertEqual(snv['pos'], "64048166") # test 29 def test_undirected_SNV_stoploss_exists(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "STOPLOSS", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.negative_transcript).get_vcf_row() self.assertIn(snv['pos'], ["64048166", "64048167", "64048168"]) # test 29 def test_undirected_SNV(self): snv = { "TYPE": "SNV", "REGION": "CODING", "IMPACT": { "SNV_TYPE": "ANY", "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } snv = SNV(snv, self.negative_transcript).get_vcf_row()
class DeletionMethodTestCase(unittest.TestCase): time.sleep(2) # positive_transcript = Transcript(64805) # SOX9 SOX9_uid = get_all_transcripts("SOX9", "grch38")[0]["qualifiers"]["uid"] positive_transcript = Transcript(SOX9_uid, "grch38") # test 11 def test_basic_deletion(self): indel = { 'TYPE': 'INDEL', 'REGION': 'CODING', 'IMPACT': { "INDEL_AMOUNT": -5, "START": 72121500 }, "ZYGOSITY": "HETEROZYGOUS" } indel = Indel(indel, self.positive_transcript) deletion = indel.get_deletion() self.assertEqual(deletion["ref"], "TCGGGC") self.assertEqual(deletion["alt"], "T") self.assertEqual(deletion["pos"], 72121499) # test 12 def test_any_location_deletion(self): indel = { 'TYPE': 'INDEL', 'REGION': 'CODING', 'IMPACT': { "INDEL_AMOUNT": -5, "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } indel = Indel(indel, self.positive_transcript) deletion = indel.get_deletion() self.assertEqual(len(deletion["ref"]), 6) self.assertEqual(len(deletion["alt"]), 1) # test 13 def test_raises_length_over_200(self): indel = { 'TYPE': 'INDEL', 'REGION': 'CODING', 'IMPACT': { "INDEL_AMOUNT": 570, "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Indel(indel, self.positive_transcript).get_deletion() # test 14 def test_raises_length_greater_than_region(self): SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"] SOX18 = Transcript(SOX18_uid, "grch38") indel = { 'TYPE': 'INDEL', 'REGION': 'INTRONIC', 'IMPACT': { "INDEL_AMOUNT": -199, "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Indel(indel, SOX18) # test 15 def test_raises_length_greater_than_location(self): SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"] SOX18 = Transcript(SOX18_uid, "grch38") indel = { 'TYPE': 'INDEL', 'REGION': 'INTRONIC', 'IMPACT': { "INDEL_AMOUNT": -150, "START": 64049150 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): indel = Indel(indel, SOX18)
class IndelCreationTests(unittest.TestCase): time.sleep(2) XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(XKR8_uid, "grch38") SOX18_uid = get_all_transcripts("SOX18", "grch38")[0]["qualifiers"]["uid"] SOX18 = Transcript(SOX18_uid, "grch38") # test 1 def test_wrong_keys(self): indel = { "TYPE": "INDEL", "REGION": "INTRONIC", "check": 5, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(KeyError): Indel(indel, self.transcript) # test 2 def test_region_value(self): indel = { "TYPE": "INDEL", "REGION": "TEST", "IMPACT": { "INDEL_AMOUNT": 5, "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Indel(indel, self.transcript) # test 3 def test_type_value(self): indel = { "TYPE": "TEST", "REGION": "INTRONIC", "IMPACT": { "INDEL_AMOUNT": 5, "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Indel(indel, self.transcript) # test 4 def test_type_value_indel(self): indel = { "TYPE": "SNV", "REGION": "INTRONIC", "IMPACT": { "INDEL_AMOUNT": 8332, "START": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Indel(indel, self.transcript) # test 5 def test_location_0(self): indel = { "TYPE": "INDEL", "REGION": "INTRONIC", "IMPACT": { "INDEL_AMOUNT": 5, "START": 0 }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Indel(indel, self.SOX18).get_vcf_row() # test 6 def test_location_str(self): indel = { "TYPE": "INDEL", "REGION": "INTRONIC", "IMPACT": { "INDEL_AMOUNT": 5, "START": "four" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Indel(indel, self.SOX18).get_vcf_row()
class STRBasicTests(unittest.TestCase): WASH7P_uid = get_all_transcripts("WASH7P", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(WASH7P_uid, "grch38") STR_uid = get_strs(16620, 16631, "1", "grch38", "exact")[0]["qualifiers"]["uid"] # test 1 def test_correct_motif(self): STR = { "IMPACT": { "STR_ID": self.STR_uid, "LENGTH": 2, }, "REGION": "UTR", "TYPE": "STR", "ZYGOSITY": "HETEROZYGOUS" } STR = ShortTandemRepeat(STR, self.transcript) self.assertEqual(STR.motif, "GCT") def test_retraction_too_large(self): STR = { "IMPACT": { "STR_ID": self.STR_uid, "LENGTH": -50, }, "REGION": "GENIC", "TYPE": "STR", "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(TypeError): ShortTandemRepeat(STR, self.transcript) def test_retraction_works(self): STR = { "IMPACT": { "STR_ID": self.STR_uid, "LENGTH": -2, }, "REGION": "UTR", "TYPE": "STR", "ZYGOSITY": "HETEROZYGOUS" } STR = ShortTandemRepeat(STR, self.transcript) vcf_row = STR.get_vcf_row() self.assertEqual(vcf_row['pos'], "16619") self.assertEqual(vcf_row['ref'], "CGCTGCT") self.assertEqual(vcf_row['alt'], "C") def test_insertion_too_large(self): STR = { "IMPACT": { "STR_ID": self.STR_uid, "LENGTH": 10000, }, "REGION": "UTR", "TYPE": "STR", "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(Exception) as cm: STR = ShortTandemRepeat(STR, self.transcript) err = cm.exception self.assertEqual(str(err), 'expansion length is too large') def test_insertion_works(self): STR = { "IMPACT": { "STR_ID": self.STR_uid, "LENGTH": 5, }, "REGION": "UTR", "TYPE": "STR", "ZYGOSITY": "HETEROZYGOUS" } STR = ShortTandemRepeat(STR, self.transcript) vcf_row = STR.get_vcf_row() self.assertEqual(vcf_row['pos'], "16620") self.assertEqual(vcf_row['ref'], "GCT") self.assertEqual(vcf_row['alt'], "GCTGCTGCTGCTGCTGCT")
class VariantCreationTests(unittest.TestCase): XKR8_uid = get_all_transcripts("XKR8", "grch38")[0]["qualifiers"]["uid"] transcript = Transcript(XKR8_uid, "grch38") def test_bad_formatting(self): variant = { "TYPE": "INDEL", "REGION": "INTRONIC", "CHECK": -8332, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(KeyError): Variant(variant, self.transcript) def test_region_fail(self): variant = { "TYPE": "INDEL", "REGION": "TEST", "IMPACT": { "INDEL_AMOUNT": -400, "LOCATION": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Variant(variant, self.transcript) def test_region_fail2(self): variant = { "TYPE": "INDEL", "REGION": "2:126-245a", "IMPACT": { "INDEL_AMOUNT": -400, "LOCATION": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Variant(variant, self.transcript) def test_region_pass(self): variant = { "TYPE": "INDEL", "REGION": "2:126-245", "IMPACT": { "INDEL_AMOUNT": -400, "LOCATION": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } good_var = Variant(variant, self.transcript) def test_type_fail(self): variant = { "TYPE": "TEST", "REGION": "INTRONIC", "IMPACT": { "INDEL_AMOUNT": -400, "LOCATION": "ANY" }, "ZYGOSITY": "HETEROZYGOUS" } with self.assertRaises(ValueError): Variant(variant, self.transcript)
def test_assert_raises(self): with self.assertRaises(Exception) as cm: Transcript(9000000, 'grch38') err = cm.exception self.assertEqual(str(err), 'cannot make transcript')