class TestAutosomalPy(unittest.TestCase): """ test the Autosomal class """ def setUp(self): """ define a family and variant, and start the Autosomal class """ # generate a test family child_gender = "F" mom_aff = "1" dad_aff = "1" self.trio = self.create_family(child_gender, mom_aff, dad_aff) # generate a test variant child_var = self.create_snv(child_gender, "0/1") mom_var = self.create_snv("F", "0/0") dad_var = self.create_snv("M", "0/0") var = TrioGenotypes(child_var) var.add_mother_variant(mom_var) var.add_father_variant(dad_var) self.variants = [var] # make sure we've got known genes data self.known_genes = { "TEST": { "inh": ["Monoallelic"], "confirmed_status": ["Confirmed DD Gene"] } } self.inh = Autosomal(self.variants, self.trio, self.known_genes, "TEST") self.inh.is_lof = var.child.is_lof() def create_snv(self, gender, genotype): """ create a default variant """ chrom = "1" pos = "15000000" snp_id = "." ref = "A" alt = "G" filt = "PASS" # set up a SNV object, since SNV inherits VcfInfo var = SNV(chrom, pos, snp_id, ref, alt, filt) info = "HGNC=TEST;CQ=missense_variant;random_tag" format_keys = "GT:DP" sample_values = genotype + ":50" var.add_info(info) var.add_format(format_keys, sample_values) var.set_gender(gender) var.set_genotype() return var def create_cnv(self, gender, inh, chrom, pos): """ create a default variant """ snp_id = "." ref = "A" alt = "<DUP>" filt = "PASS" # set up a SNV object, since SNV inherits VcfInfo var = CNV(chrom, pos, snp_id, ref, alt, filt) info = "HGNC=TEST;HGNC_ALL=TEST;END=16000000;SVLEN=5000" format_keys = "INHERITANCE:DP" sample_values = inh + ":50" var.add_info(info) var.add_format(format_keys, sample_values) var.set_gender(gender) var.set_genotype() return var def create_family(self, child_gender, mom_aff, dad_aff): """ create a default family, with optional gender and parental statuses """ fam = Family("test") fam.add_child("child", "child_vcf", "2", child_gender) fam.add_mother("mother", "mother_vcf", mom_aff, "2") fam.add_father("father", "father_vcf", dad_aff, "1") fam.set_child() return fam def set_trio_genos(self, var, geno): """ convenience function to set the trio genotypes for a variant """ genos = {"0": "0/0", "1": "0/1", "2": "1/1"} # convert the geno codes to allele codes child = genos[geno[0]] mom = genos[geno[1]] dad = genos[geno[2]] # set the genotype field for each individual var.child.format["GT"] = child var.mother.format["GT"] = mom var.father.format["GT"] = dad # and set th genotype for each individual var.child.set_genotype() var.mother.set_genotype() var.father.set_genotype() # set the trio genotypes for the inheritance object self.inh.set_trio_genotypes(var) def test_check_variant_without_parents(self): """ test that check_variant_without_parents() works correctly """ var = self.variants[0] self.set_trio_genos(var, "100") # remove the parents, so it appears the var lacks parental information self.inh.trio.mother = None self.inh.trio.father = None # check for monoallelic inheritance self.assertEqual(self.inh.check_variant_without_parents("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "autosomal without parents") # check for biallelic inheritance self.assertEqual(self.inh.check_variant_without_parents("Biallelic"), "compound_het") self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_variant_without_parents("Monoallelic"), "nothing") self.assertEqual(self.inh.check_variant_without_parents("Biallelic"), "single_variant") def test_check_heterozygous_de_novo(self): """ test that check_heterozygous() works correctly for de novos """ var = self.variants[0] self.inh.set_trio_genotypes(var) # check for monoallelic inheritance self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "de novo as single_variant") # check for biallelic inheritance self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "de novo as compound_het") for geno in ["101", "102", "110", "112", "122"]: self.set_trio_genos(var, geno) self.inh.check_heterozygous("Monoallelic") self.assertNotEqual(self.inh.log_string, "de novo as single_variant") def test_check_heterozygous_affected_mother(self): """ test that check_heterozygous() works correctly for affected mothers """ var = self.variants[0] # check that trio = 110, with het affected mother is captured self.set_trio_genos(var, "110") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check that when the other parent is also non-ref, the variant is no # longer captured, unless the parent is affected self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "nothing") self.assertEqual( self.inh.log_string, "typically for trios with non-de novo unaffected parents") self.inh.father_affected = True self.inh.check_heterozygous("Monoallelic") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") def test_check_heterozygous_affected_father(self): """ test that check_heterozygous() works correctly for affected fathers """ var = self.variants[0] # set the father as non-ref genotype and affected self.set_trio_genos(var, "101") self.inh.father_affected = True # check that the het proband, with het affected father is captured self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check that when the other parent is also non-ref, the variant is no # longer captured, unless the parent is affected self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "nothing") self.assertEqual( self.inh.log_string, "typically for trios with non-de novo unaffected parents") self.inh.mother_affected = True self.inh.check_heterozygous("Monoallelic") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") def test_check_heterozygous_biallelic_non_ref_father(self): """ test that check_heterozygous() works correctly for biallelic genes """ var = self.variants[0] # check for trio = 101 self.set_trio_genos(var, "101") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check that trio = 102, with affected father comes through other route self.set_trio_genos(var, "102") self.inh.father_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check for trio = 102, without affected father self.inh.father_affected = False self.assertEqual(self.inh.check_heterozygous("Biallelic"), "nothing") self.assertEqual( self.inh.log_string, "typically for trios with non-de novo unaffected parents") def test_check_heterozygous_biallelic_non_ref_mother(self): """ test that check_heterozygous() works correctly for biallelic genes """ # check for trio = 110 var = self.variants[0] self.set_trio_genos(var, "110") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 120, with affected mother comes through other route var = self.variants[0] self.set_trio_genos(var, "120") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check for trio = 120, without affected mother self.set_trio_genos(var, "120") self.inh.mother_affected = False self.assertEqual(self.inh.check_heterozygous("Biallelic"), "nothing") self.assertEqual( self.inh.log_string, "typically for trios with non-de novo unaffected parents") def test_check_heterozygous_biallelic_both_parents_non_ref(self): """ test that check_heterozygous() works correctly for biallelic genes """ # check for trio = 111 var = self.variants[0] self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 121 with affected mother, but unaffected father self.set_trio_genos(var, "121") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 112 with affected father, but unaffected mother self.set_trio_genos(var, "112") self.inh.mother_affected = False self.inh.father_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") def test_check_homozygous(self): """ test that check_homozygous() works correctly """ var = self.variants[0] # check for trio = 200, which is non-mendelian self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check for 201, which is non-mendelian self.set_trio_genos(var, "201") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check for 210, which is non-mendelian self.set_trio_genos(var, "210") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") def test_check_homozygous_with_cnv(self): """ test that check_homozygous() works correctly for variant lists with CNVs """ # generate a test variant chrom = "1" position = "60000" child_var = self.create_cnv("F", "unknown", chrom, position) mom_var = self.create_cnv("F", "unknown", chrom, position) dad_var = self.create_cnv("M", "unknown", chrom, position) cnv_var = TrioGenotypes(child_var) cnv_var.add_mother_variant(mom_var) cnv_var.add_father_variant(dad_var) var = self.variants[0] # check for trio = 200, which is non-mendelian self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check when a CNV is in the variants list self.inh.variants.append(cnv_var) self.assertEqual(self.inh.check_homozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "non-mendelian, but CNV might affect call") def test_check_homozygous_biallelic(self): """ test that check_homozygous() works correctly for biallelic genes """ var = self.variants[0] # check for trio = 211 self.set_trio_genos(var, "211") self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "both parents het in biallelic gene") # and check for trio = 221, but unaffected mother self.set_trio_genos(var, "221") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # and check for trio = 221, with affected mother self.inh.mother_affected = True self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") # and check for trio = 222, with affected mother only, should fail self.set_trio_genos(var, "222") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # and check for trio = 222, with both parents affected self.inh.father_affected = True self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") # and check for trio = 212, with affected father self.set_trio_genos(var, "212") self.inh.father_affected = True self.inh.mother_affected = False self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") def test_check_homozygous_monoallelic(self): """ test that check_homozygous() works correctly for monoallelic genes """ var = self.variants[0] # check for trio = 211, without affected father self.set_trio_genos(var, "211") self.assertEqual(self.inh.check_homozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # check for trio = 211, with affected father only self.inh.father_affected = True self.assertEqual(self.inh.check_homozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # check for trio = 211, with both parents affected self.inh.mother_affected = True self.assertEqual(self.inh.check_homozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "transmitted from affected parents")
class TestAutosomalPy(unittest.TestCase): """ test the Autosomal class """ def setUp(self): """ define a family and variant, and start the Autosomal class """ # generate a test family sex = "F" mom_aff = "1" dad_aff = "1" self.trio = self.create_family(sex, mom_aff, dad_aff) # generate a test variant child = create_snv(sex, "0/1") mom = create_snv("F", "0/0") dad = create_snv("M", "0/0") var = TrioGenotypes(child.get_chrom(), child.get_position(),child, mom, dad) self.variants = [var] # make sure we've got known genes data self.known_gene = {"inh": ["Monoallelic"], "confirmed_status": ["confirmed dd gene"]} self.inh = Autosomal(self.variants, self.trio, self.known_gene, "1001") self.inh.is_lof = var.child.is_lof() def create_family(self, child_gender, mom_aff, dad_aff): """ create a default family, with optional gender and parental statuses """ fam = Family('test') fam.add_child('child', 'mother', 'father', child_gender, '2', 'child_vcf') fam.add_mother('mother', '0', '0', 'female', mom_aff, 'mother_vcf') fam.add_father('father', '0', '0', 'male', dad_aff, 'father_vcf') fam.set_child() return fam def set_trio_genos(self, var, geno): """ convenience function to set the trio genotypes for a variant """ genos = {"0": "0/0", "1": "0/1", "2": "1/1"} # convert the geno codes to allele codes child = genos[geno[0]] mom = genos[geno[1]] dad = genos[geno[2]] # set the genotype field for each individual var.child.format["GT"] = child var.mother.format["GT"] = mom var.father.format["GT"] = dad # and set th genotype for each individual var.child.set_genotype() var.mother.set_genotype() var.father.set_genotype() # set the trio genotypes for the inheritance object self.inh.set_trio_genotypes(var) def test_check_variant_without_parents(self): """ test that check_variant_without_parents() works correctly """ var = self.variants[0] self.set_trio_genos(var, "100") # remove the parents, so it appears the var lacks parental information self.inh.trio.mother = None self.inh.trio.father = None # check for monoallelic inheritance self.assertEqual(self.inh.check_variant_without_parents("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "autosomal without parents") # check for biallelic inheritance self.assertEqual(self.inh.check_variant_without_parents("Biallelic"), "compound_het") self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_variant_without_parents("Monoallelic"), "nothing") self.assertEqual(self.inh.check_variant_without_parents("Biallelic"), "single_variant") def test_check_heterozygous_de_novo(self): """ test that check_heterozygous() works correctly for de novos """ var = self.variants[0] self.inh.set_trio_genotypes(var) # check for monoallelic inheritance self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "de novo as single_variant") # mosaic should operate as per monoallelic self.assertEqual(self.inh.check_heterozygous("Mosaic"), "single_variant") # check for biallelic inheritance self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "de novo as compound_het") for geno in ["101", "102", "110", "112", "122"]: self.set_trio_genos(var, geno) self.inh.check_heterozygous("Monoallelic") self.assertNotEqual(self.inh.log_string, "de novo as single_variant") def test_check_heterozygous_affected_mother(self): """ test that check_heterozygous() works correctly for affected mothers """ var = self.variants[0] # check that trio = 110, with het affected mother is captured self.set_trio_genos(var, "110") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # mosaic should operate as per monoallelic self.assertEqual(self.inh.check_heterozygous("Mosaic"), "single_variant") # check that when the other parent is also non-ref, the variant is no # longer captured, unless the parent is affected self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "typically for trios with non-de novo unaffected parents") # mosaic should operate as per monoallelic self.assertEqual(self.inh.check_heterozygous("Mosaic"), "nothing") self.inh.father_affected = True self.inh.check_heterozygous("Monoallelic") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") def test_check_heterozygous_affected_father(self): """ test that check_heterozygous() works correctly for affected fathers """ var = self.variants[0] # set the father as non-ref genotype and affected self.set_trio_genos(var, "101") self.inh.father_affected = True # check that the het proband, with het affected father is captured self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check that when the other parent is also non-ref, the variant is no # longer captured, unless the parent is affected self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "typically for trios with non-de novo unaffected parents") self.inh.mother_affected = True self.inh.check_heterozygous("Monoallelic") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") def test_check_heterozygous_biallelic_non_ref_father(self): """ test that check_heterozygous() works correctly for biallelic genes """ var = self.variants[0] # check for trio = 101 self.set_trio_genos(var, "101") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check that trio = 102, with affected father comes through other route self.set_trio_genos(var, "102") self.inh.father_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check for trio = 102, without affected father self.inh.father_affected = False self.assertEqual(self.inh.check_heterozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "typically for trios with non-de novo unaffected parents") def test_check_heterozygous_biallelic_non_ref_mother(self): """ test that check_heterozygous() works correctly for biallelic genes """ # check for trio = 110 var = self.variants[0] self.set_trio_genos(var, "110") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 120, with affected mother comes through other route var = self.variants[0] self.set_trio_genos(var, "120") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check for trio = 120, without affected mother self.set_trio_genos(var, "120") self.inh.mother_affected = False self.assertEqual(self.inh.check_heterozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "typically for trios with non-de novo unaffected parents") def test_check_heterozygous_biallelic_both_parents_non_ref(self): """ test that check_heterozygous() works correctly for biallelic genes """ # check for trio = 111 var = self.variants[0] self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 121 with affected mother, but unaffected father self.set_trio_genos(var, "121") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 112 with affected father, but unaffected mother self.set_trio_genos(var, "112") self.inh.mother_affected = False self.inh.father_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") def test_check_homozygous(self): """ test that check_homozygous() works correctly """ var = self.variants[0] # check for trio = 200, which is non-mendelian self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check for 201, which is non-mendelian self.set_trio_genos(var, "201") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check for 210, which is non-mendelian self.set_trio_genos(var, "210") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") def test_check_homozygous_with_cnv(self): """ test that check_homozygous() works correctly for variant lists with CNVs """ # generate a test variant chrom = "1" position = "60000" child = create_cnv("F", "unknown", chrom=chrom, pos=position) mom = create_cnv("F", "unknown", chrom=chrom, pos=position) dad = create_cnv("M", "unknown", chrom=chrom, pos=position) cnv = TrioGenotypes(chrom, position, child, mom, dad) var = self.variants[0] # check for trio = 200, which is non-mendelian self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check when a CNV is in the variants list self.inh.variants.append(cnv) self.assertEqual(self.inh.check_homozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "non-mendelian, but CNV might affect call") def test_check_homozygous_biallelic(self): """ test that check_homozygous() works correctly for biallelic genes """ var = self.variants[0] # check for trio = 211 self.set_trio_genos(var, "211") self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "both parents het in biallelic gene") # and check for trio = 221, but unaffected mother self.set_trio_genos(var, "221") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # and check for trio = 221, with affected mother self.inh.mother_affected = True self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") # and check for trio = 222, with affected mother only, should fail self.set_trio_genos(var, "222") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # and check for trio = 222, with both parents affected self.inh.father_affected = True self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") # and check for trio = 212, with affected father self.set_trio_genos(var, "212") self.inh.father_affected = True self.inh.mother_affected = False self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") def test_check_homozygous_monoallelic(self): """ test that check_homozygous() works correctly for monoallelic genes """ var = self.variants[0] # check for trio = 211, without affected father self.set_trio_genos(var, "211") self.assertEqual(self.inh.check_homozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # check for trio = 211, with affected father only self.inh.father_affected = True self.assertEqual(self.inh.check_homozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # check for trio = 211, with both parents affected self.inh.mother_affected = True self.assertEqual(self.inh.check_homozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "transmitted from affected parents")
class TestAutosomalPy(unittest.TestCase): """ test the Autosomal class """ def setUp(self): """ define a family and variant, and start the Autosomal class """ # generate a test family sex = "F" mom_aff = "1" dad_aff = "1" self.trio = self.create_family(sex, mom_aff, dad_aff) # generate a test variant child = create_snv(sex, "0/1") mom = create_snv("F", "0/0") dad = create_snv("M", "0/0") var = TrioGenotypes(child.get_chrom(), child.get_position(), child, mom, dad) self.variants = [var] # make sure we've got known genes data self.known_gene = { "inh": ["Monoallelic"], "confirmed_status": ["confirmed dd gene"] } self.inh = Autosomal(self.variants, self.trio, self.known_gene, "1001") self.inh.is_lof = var.child.is_lof() def create_family(self, child_gender, mom_aff, dad_aff): """ create a default family, with optional gender and parental statuses """ fam = Family('test') fam.add_child('child', 'mother', 'father', child_gender, '2', 'child_vcf') fam.add_mother('mother', '0', '0', 'female', mom_aff, 'mother_vcf') fam.add_father('father', '0', '0', 'male', dad_aff, 'father_vcf') fam.set_child() return fam def set_trio_genos(self, var, geno): """ convenience function to set the trio genotypes for a variant """ genos = {"0": "0/0", "1": "0/1", "2": "1/1"} # convert the geno codes to allele codes child = genos[geno[0]] mom = genos[geno[1]] dad = genos[geno[2]] # set the genotype field for each individual var.child.format["GT"] = child var.mother.format["GT"] = mom var.father.format["GT"] = dad # and set th genotype for each individual var.child.set_genotype() var.mother.set_genotype() var.father.set_genotype() # set the trio genotypes for the inheritance object self.inh.set_trio_genotypes(var) def test_check_variant_without_parents(self): """ test that check_variant_without_parents() works correctly """ var = self.variants[0] self.set_trio_genos(var, "100") # remove the parents, so it appears the var lacks parental information self.inh.trio.mother = None self.inh.trio.father = None # check for monoallelic inheritance self.assertEqual(self.inh.check_variant_without_parents("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "autosomal without parents") # check for biallelic inheritance self.assertEqual(self.inh.check_variant_without_parents("Biallelic"), "compound_het") self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_variant_without_parents("Monoallelic"), "nothing") self.assertEqual(self.inh.check_variant_without_parents("Biallelic"), "single_variant") def test_check_heterozygous_de_novo(self): """ test that check_heterozygous() works correctly for de novos """ var = self.variants[0] self.inh.set_trio_genotypes(var) # check for monoallelic inheritance self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "de novo as single_variant") # mosaic should operate as per monoallelic self.assertEqual(self.inh.check_heterozygous("Mosaic"), "single_variant") # check for biallelic inheritance self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "de novo as compound_het") for geno in ["101", "102", "110", "112", "122"]: self.set_trio_genos(var, geno) self.inh.check_heterozygous("Monoallelic") self.assertNotEqual(self.inh.log_string, "de novo as single_variant") def test_check_heterozygous_affected_mother(self): """ test that check_heterozygous() works correctly for affected mothers """ var = self.variants[0] # check that trio = 110, with het affected mother is captured self.set_trio_genos(var, "110") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # mosaic should operate as per monoallelic self.assertEqual(self.inh.check_heterozygous("Mosaic"), "single_variant") # check that when the other parent is also non-ref, the variant is no # longer captured, unless the parent is affected self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "nothing") self.assertEqual( self.inh.log_string, "typically for trios with non-de novo unaffected parents") # mosaic should operate as per monoallelic self.assertEqual(self.inh.check_heterozygous("Mosaic"), "nothing") self.inh.father_affected = True self.inh.check_heterozygous("Monoallelic") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") def test_check_heterozygous_affected_father(self): """ test that check_heterozygous() works correctly for affected fathers """ var = self.variants[0] # set the father as non-ref genotype and affected self.set_trio_genos(var, "101") self.inh.father_affected = True # check that the het proband, with het affected father is captured self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check that when the other parent is also non-ref, the variant is no # longer captured, unless the parent is affected self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "nothing") self.assertEqual( self.inh.log_string, "typically for trios with non-de novo unaffected parents") self.inh.mother_affected = True self.inh.check_heterozygous("Monoallelic") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") def test_check_heterozygous_biallelic_non_ref_father(self): """ test that check_heterozygous() works correctly for biallelic genes """ var = self.variants[0] # check for trio = 101 self.set_trio_genos(var, "101") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check that trio = 102, with affected father comes through other route self.set_trio_genos(var, "102") self.inh.father_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check for trio = 102, without affected father self.inh.father_affected = False self.assertEqual(self.inh.check_heterozygous("Biallelic"), "nothing") self.assertEqual( self.inh.log_string, "typically for trios with non-de novo unaffected parents") def test_check_heterozygous_biallelic_non_ref_mother(self): """ test that check_heterozygous() works correctly for biallelic genes """ # check for trio = 110 var = self.variants[0] self.set_trio_genos(var, "110") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 120, with affected mother comes through other route var = self.variants[0] self.set_trio_genos(var, "120") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check for trio = 120, without affected mother self.set_trio_genos(var, "120") self.inh.mother_affected = False self.assertEqual(self.inh.check_heterozygous("Biallelic"), "nothing") self.assertEqual( self.inh.log_string, "typically for trios with non-de novo unaffected parents") def test_check_heterozygous_biallelic_both_parents_non_ref(self): """ test that check_heterozygous() works correctly for biallelic genes """ # check for trio = 111 var = self.variants[0] self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 121 with affected mother, but unaffected father self.set_trio_genos(var, "121") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 112 with affected father, but unaffected mother self.set_trio_genos(var, "112") self.inh.mother_affected = False self.inh.father_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual( self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") def test_check_homozygous(self): """ test that check_homozygous() works correctly """ var = self.variants[0] # check for trio = 200, which is non-mendelian self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check for 201, which is non-mendelian self.set_trio_genos(var, "201") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check for 210, which is non-mendelian self.set_trio_genos(var, "210") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") def test_check_homozygous_with_cnv(self): """ test that check_homozygous() works correctly for variant lists with CNVs """ # generate a test variant chrom = "1" position = "60000" child = create_cnv("F", "unknown", chrom=chrom, pos=position) mom = create_cnv("F", "unknown", chrom=chrom, pos=position) dad = create_cnv("M", "unknown", chrom=chrom, pos=position) cnv = TrioGenotypes(chrom, position, child, mom, dad) var = self.variants[0] # check for trio = 200, which is non-mendelian self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check when a CNV is in the variants list self.inh.variants.append(cnv) self.assertEqual(self.inh.check_homozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "non-mendelian, but CNV might affect call") def test_check_homozygous_biallelic(self): """ test that check_homozygous() works correctly for biallelic genes """ var = self.variants[0] # check for trio = 211 self.set_trio_genos(var, "211") self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "both parents het in biallelic gene") # and check for trio = 221, but unaffected mother self.set_trio_genos(var, "221") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # and check for trio = 221, with affected mother self.inh.mother_affected = True self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") # and check for trio = 222, with affected mother only, should fail self.set_trio_genos(var, "222") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # and check for trio = 222, with both parents affected self.inh.father_affected = True self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") # and check for trio = 212, with affected father self.set_trio_genos(var, "212") self.inh.father_affected = True self.inh.mother_affected = False self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") def test_check_homozygous_monoallelic(self): """ test that check_homozygous() works correctly for monoallelic genes """ var = self.variants[0] # check for trio = 211, without affected father self.set_trio_genos(var, "211") self.assertEqual(self.inh.check_homozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # check for trio = 211, with affected father only self.inh.father_affected = True self.assertEqual(self.inh.check_homozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # check for trio = 211, with both parents affected self.inh.mother_affected = True self.assertEqual(self.inh.check_homozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "transmitted from affected parents")
class TestAutosomalPy(unittest.TestCase): """ test the Autosomal class """ def setUp(self): """ define a family and variant, and start the Autosomal class """ # generate a test family child_gender = "F" mom_aff = "1" dad_aff = "1" self.trio = self.create_family(child_gender, mom_aff, dad_aff) # generate a test variant child_var = self.create_snv(child_gender, "0/1") mom_var = self.create_snv("F", "0/0") dad_var = self.create_snv("M", "0/0") var = TrioGenotypes(child_var) var.add_mother_variant(mom_var) var.add_father_variant(dad_var) self.variants = [var] # make sure we've got known genes data self.known_genes = {"TEST": {"inh": ["Monoallelic"], "confirmed_status": ["Confirmed DD Gene"]}} self.inh = Autosomal(self.variants, self.trio, self.known_genes, "TEST") self.inh.is_lof = var.child.is_lof() def create_snv(self, gender, genotype): """ create a default variant """ chrom = "1" pos = "15000000" snp_id = "." ref = "A" alt = "G" filt = "PASS" # set up a SNV object, since SNV inherits VcfInfo var = SNV(chrom, pos, snp_id, ref, alt, filt) info = "HGNC=TEST;CQ=missense_variant;random_tag" format_keys = "GT:DP" sample_values = genotype + ":50" var.add_info(info) var.add_format(format_keys, sample_values) var.set_gender(gender) var.set_genotype() return var def create_cnv(self, gender, inh, chrom, pos): """ create a default variant """ snp_id = "." ref = "A" alt = "<DUP>" filt = "PASS" # set up a SNV object, since SNV inherits VcfInfo var = CNV(chrom, pos, snp_id, ref, alt, filt) info = "HGNC=TEST;HGNC_ALL=TEST;END=16000000;SVLEN=5000" format_keys = "INHERITANCE:DP" sample_values = inh + ":50" var.add_info(info) var.add_format(format_keys, sample_values) var.set_gender(gender) var.set_genotype() return var def create_family(self, child_gender, mom_aff, dad_aff): """ create a default family, with optional gender and parental statuses """ fam = Family("test") fam.add_child("child", "child_vcf", "2", child_gender) fam.add_mother("mother", "mother_vcf", mom_aff, "2") fam.add_father("father", "father_vcf", dad_aff, "1") fam.set_child() return fam def set_trio_genos(self, var, geno): """ convenience function to set the trio genotypes for a variant """ genos = {"0": "0/0", "1": "0/1", "2": "1/1"} # convert the geno codes to allele codes child = genos[geno[0]] mom = genos[geno[1]] dad = genos[geno[2]] # set the genotype field for each individual var.child.format["GT"] = child var.mother.format["GT"] = mom var.father.format["GT"] = dad # and set th genotype for each individual var.child.set_genotype() var.mother.set_genotype() var.father.set_genotype() # set the trio genotypes for the inheritance object self.inh.set_trio_genotypes(var) def test_check_variant_without_parents(self): """ test that check_variant_without_parents() works correctly """ var = self.variants[0] self.set_trio_genos(var, "100") # remove the parents, so it appears the var lacks parental information self.inh.trio.mother = None self.inh.trio.father = None # check for monoallelic inheritance self.assertEqual(self.inh.check_variant_without_parents("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "autosomal without parents") # check for biallelic inheritance self.assertEqual(self.inh.check_variant_without_parents("Biallelic"), "compound_het") self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_variant_without_parents("Monoallelic"), "nothing") self.assertEqual(self.inh.check_variant_without_parents("Biallelic"), "single_variant") def test_check_heterozygous_de_novo(self): """ test that check_heterozygous() works correctly for de novos """ var = self.variants[0] self.inh.set_trio_genotypes(var) # check for monoallelic inheritance self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "de novo as single_variant") # check for biallelic inheritance self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "de novo as compound_het") for geno in ["101", "102", "110", "112", "122"]: self.set_trio_genos(var, geno) self.inh.check_heterozygous("Monoallelic") self.assertNotEqual(self.inh.log_string, "de novo as single_variant") def test_check_heterozygous_affected_mother(self): """ test that check_heterozygous() works correctly for affected mothers """ var = self.variants[0] # check that trio = 110, with het affected mother is captured self.set_trio_genos(var, "110") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check that when the other parent is also non-ref, the variant is no # longer captured, unless the parent is affected self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "typically for trios with non-de novo unaffected parents") self.inh.father_affected = True self.inh.check_heterozygous("Monoallelic") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") def test_check_heterozygous_affected_father(self): """ test that check_heterozygous() works correctly for affected fathers """ var = self.variants[0] # set the father as non-ref genotype and affected self.set_trio_genos(var, "101") self.inh.father_affected = True # check that the het proband, with het affected father is captured self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check that when the other parent is also non-ref, the variant is no # longer captured, unless the parent is affected self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "typically for trios with non-de novo unaffected parents") self.inh.mother_affected = True self.inh.check_heterozygous("Monoallelic") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") def test_check_heterozygous_biallelic_non_ref_father(self): """ test that check_heterozygous() works correctly for biallelic genes """ var = self.variants[0] # check for trio = 101 self.set_trio_genos(var, "101") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check that trio = 102, with affected father comes through other route self.set_trio_genos(var, "102") self.inh.father_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check for trio = 102, without affected father self.inh.father_affected = False self.assertEqual(self.inh.check_heterozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "typically for trios with non-de novo unaffected parents") def test_check_heterozygous_biallelic_non_ref_mother(self): """ test that check_heterozygous() works correctly for biallelic genes """ # check for trio = 110 var = self.variants[0] self.set_trio_genos(var, "110") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 120, with affected mother comes through other route var = self.variants[0] self.set_trio_genos(var, "120") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "transmitted from aff, other parent non-carrier or aff") # check for trio = 120, without affected mother self.set_trio_genos(var, "120") self.inh.mother_affected = False self.assertEqual(self.inh.check_heterozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "typically for trios with non-de novo unaffected parents") def test_check_heterozygous_biallelic_both_parents_non_ref(self): """ test that check_heterozygous() works correctly for biallelic genes """ # check for trio = 111 var = self.variants[0] self.set_trio_genos(var, "111") self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 121 with affected mother, but unaffected father self.set_trio_genos(var, "121") self.inh.mother_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") # check for trio = 112 with affected father, but unaffected mother self.set_trio_genos(var, "112") self.inh.mother_affected = False self.inh.father_affected = True self.assertEqual(self.inh.check_heterozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "het-check for recessive genes and unaff parents not homoz") def test_check_homozygous(self): """ test that check_homozygous() works correctly """ var = self.variants[0] # check for trio = 200, which is non-mendelian self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check for 201, which is non-mendelian self.set_trio_genos(var, "201") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check for 210, which is non-mendelian self.set_trio_genos(var, "210") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") def test_check_homozygous_with_cnv(self): """ test that check_homozygous() works correctly for variant lists with CNVs """ # generate a test variant chrom = "1" position = "60000" child_var = self.create_cnv("F", "unknown", chrom, position) mom_var = self.create_cnv("F", "unknown", chrom, position) dad_var = self.create_cnv("M", "unknown", chrom, position) cnv_var = TrioGenotypes(child_var) cnv_var.add_mother_variant(mom_var) cnv_var.add_father_variant(dad_var) var = self.variants[0] # check for trio = 200, which is non-mendelian self.set_trio_genos(var, "200") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-mendelian trio") # check when a CNV is in the variants list self.inh.variants.append(cnv_var) self.assertEqual(self.inh.check_homozygous("Biallelic"), "compound_het") self.assertEqual(self.inh.log_string, "non-mendelian, but CNV might affect call") def test_check_homozygous_biallelic(self): """ test that check_homozygous() works correctly for biallelic genes """ var = self.variants[0] # check for trio = 211 self.set_trio_genos(var, "211") self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "both parents het in biallelic gene") # and check for trio = 221, but unaffected mother self.set_trio_genos(var, "221") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # and check for trio = 221, with affected mother self.inh.mother_affected = True self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") # and check for trio = 222, with affected mother only, should fail self.set_trio_genos(var, "222") self.assertEqual(self.inh.check_homozygous("Biallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # and check for trio = 222, with both parents affected self.inh.father_affected = True self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") # and check for trio = 212, with affected father self.set_trio_genos(var, "212") self.inh.father_affected = True self.inh.mother_affected = False self.assertEqual(self.inh.check_homozygous("Biallelic"), "single_variant") self.assertEqual(self.inh.log_string, "homoz parent aff") def test_check_homozygous_monoallelic(self): """ test that check_homozygous() works correctly for monoallelic genes """ var = self.variants[0] # check for trio = 211, without affected father self.set_trio_genos(var, "211") self.assertEqual(self.inh.check_homozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # check for trio = 211, with affected father only self.inh.father_affected = True self.assertEqual(self.inh.check_homozygous("Monoallelic"), "nothing") self.assertEqual(self.inh.log_string, "non-causal homozygous variant") # check for trio = 211, with both parents affected self.inh.mother_affected = True self.assertEqual(self.inh.check_homozygous("Monoallelic"), "single_variant") self.assertEqual(self.inh.log_string, "transmitted from affected parents")