class TestScreen(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" self.output = os.path.join(self.test_folder, "output") self.tex_wig = os.path.join(self.test_folder, "tex") self.frag_wig = os.path.join(self.test_folder, "frag") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.tex_wig) os.mkdir(self.frag_wig) os.mkdir(self.output) self.fasta = os.path.join(self.test_folder, "aaa.fa") gen_file(self.fasta, self.example.fasta) args = self.mock_args.mock() args.output_folder = self.output args.fasta = self.fasta self.screen = Screen(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_screenshot(self): gen_file(os.path.join(self.tex_wig, "tex_1_f.wig"), self.example.wig_f) gen_file(os.path.join(self.tex_wig, "notex_1_f.wig"), self.example.wig_f) gen_file(os.path.join(self.frag_wig, "frag_f.wig"), self.example.wig_f) gen_file(os.path.join(self.tex_wig, "tex_1_r.wig"), self.example.wig_r) gen_file(os.path.join(self.tex_wig, "notex_1_r.wig"), self.example.wig_r) gen_file(os.path.join(self.frag_wig, "frag_r.wig"), self.example.wig_r) args = self.mock_args.mock() args.fasta = self.fasta args.main_gff = os.path.join(self.test_folder, "main.gff") gen_file(args.main_gff, self.example.main_gff) side_gff = os.path.join(self.test_folder, "side.gff") args.side_gffs = [side_gff] gen_file(side_gff, self.example.side_gff) args.frag_wigs = self.frag_wig args.tex_wigs = self.tex_wig args.height = 1000 args.tlibs = ["tex_1_f.wig:tex:1:a:+", "tex_1_r.wig:tex:1:a:-", "notex_1_f.wig:notex:1:a:+", "notex_1_r.wig:notex:1:a:-"] args.flibs = ["frag_f.wig:frag:1:a:+", "frag_r.wig:frag:1:a:-"] args.present = "expand" args.output_folder = self.output self.screen.screenshot(args) self.assertTrue(os.path.exists(os.path.join(self.output, "screenshots", "aaa", "forward"))) self.assertTrue(os.path.exists(os.path.join(self.output, "screenshots", "aaa", "reverse"))) datas = import_data(os.path.join(self.output, "screenshots", "aaa", "forward.txt")) datas = import_data(os.path.join(self.output, "screenshots", "aaa", "reverse.txt")) self.assertEqual("\n".join(datas), self.example.out_r) def test_import_libs(self): texs = [["tex_1.wig", "tex", "1", "a", "+"], ["notex_1.wig", "notex", "1", "a", "+"]] lib_dict = {"ft": [], "fn": [], "rt": [], "rn": [], "ff": [], "rf": []} self.screen._import_libs(texs, "+", self.tex_wig, lib_dict) self.assertDictEqual(lib_dict, {'fn': ['test_folder/tex/notex_1.wig'], 'rn': [], 'rt': [], 'ft': ['test_folder/tex/tex_1.wig'], 'rf': [], 'ff': []})
def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.mock_parser = Mock_Multiparser() self.test_folder = "test_folder" self.out = "test_folder/output" self.fastas = "test_folder/fastas" self.gffs = "test_folder/gffs" self.srnas = "test_folder/srnas" self.trans = "test_folder/trans" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.out) os.mkdir(self.fastas) os.mkdir(self.gffs) os.mkdir(self.srnas) os.mkdir(self.trans) os.mkdir(os.path.join(self.out, "tables")) os.mkdir(os.path.join(self.out, "gffs")) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(os.path.join(self.fastas, "tmp")) args = self.mock_args.mock() args.gffs = self.gffs args.fastas = self.fastas args.trans = self.trans args.out_folder = self.out args.srnas = self.srnas self.term = Terminator(args)
class TestGenScreenshots(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_set_data_range(self): gff_dict = {"seq_id": "aaa", "source": "Refseq", "feature": "CDS", "start": 3, "end": 6, "phase": ".", "strand": "+", "score": "."} attributes_gff = {"ID": "CDS0", "Name": "CDS_0", "locus_tag": "AAA_00001"} gff = Create_generator(gff_dict, attributes_gff, "gff") out = StringIO() gs.set_data_range(out, gff, self.example.wigs_low, "+") self.assertEqual(out.getvalue(), "setDataRange 0,20\n") out.close() out = StringIO() gs.set_data_range(out, gff, self.example.wigs_high, "+") self.assertEqual(out.getvalue(), "setDataRange 0,510\n") def test_print_batch(self): out = StringIO() lib_t = "wig1 wig2" lib_n = "wig3 wig4" lib_f = "wig5" args = self.mock_args.mock() args.fasta = "fasta" args.main_gff = "main_gff" args.present = "expend" args.height = 1000 args.side_gffs = ["test_folder/side1", "test_folder/side2"] gen_file("test_folder/side1", "test") gen_file("test_folder/side2", "test") args.output_folder = self.test_folder gs.print_batch(args, out, "+", lib_t, lib_n, lib_f, "test") self.assertEqual(out.getvalue(), self.example.out) def test_gen_batch(self): gs.import_wig = Mock_func().mock_import_wig out = StringIO() lib_t = "wig1 wig2" lib_n = "wig3 wig4" lib_f = "wig5" gff_dict = {"seq_id": "aaa", "source": "Refseq", "feature": "CDS", "start": 3, "end": 6, "phase": ".", "strand": "+", "score": "."} attributes_gff = {"ID": "CDS0", "Name": "CDS_0", "locus_tag": "AAA_00001"} gff = Create_generator(gff_dict, attributes_gff, "gff") seq = {"aaa": "ATATGGCCGACGAGTTCGACGATACAACCCGTGGGG"} gs.gen_batch(lib_t, lib_n, lib_f, "+", [gff], out, seq) self.assertEqual(out.getvalue(), self.example.out_print_wig)
def setUp(self): self.mock_args = MockClass() self.mock = Mock_func() self.mock_parser = Mock_Multiparser() self.example = Example() self.test_folder = "test_folder" self.trans = "test_folder/trans" self.out = "test_folder/output" self.tex = "test_folder/tex" self.frag = "test_folder/frag" self.gffs = "test_folder/gffs" self.tsss = "test_folder/tsss" self.terms = "test_folder/terms" self.stat = "test_folder/output/statistics" self.out_gff = "test_folder/output/gffs" self.out_table = "test_folder/output/tables" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.trans) os.mkdir(self.out) os.mkdir(self.tex) os.mkdir(self.frag) os.mkdir(os.path.join(self.frag, "tmp")) os.mkdir(self.gffs) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(self.tsss) os.mkdir(self.terms) os.mkdir(self.stat) os.mkdir(self.out_gff) os.mkdir(self.out_table) args = self.mock_args.mock() args.out_folder = self.out self.tran = TranscriptDetection(args)
class TestExtractRBS(unittest.TestCase): def setUp(self): self.example = Example() self.test_folder = "test_folder" self.mock_args = MockClass() if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_detect_site(self): inters = [{"seq": "ATGGTGACCCAGGAGGTTGATCCCAGACGTAGGACCTGTTT"}, {"seq": "TTAGGACGTACTCCTCGAATGATCAACTGATACTTA"}, {"seq": "TTTTTTTTTAAAAAAAAAATATATATTTTTTTTTTT"}] args = self.mock_args.mock() args.start_codons = ["ATG"] args.end_rbs = 14 args.start_rbs = 5 args.fuzzy_rbs = 2 ribos = er.detect_site(inters, args) self.assertListEqual(ribos, [{'seq': 'TTAGGACGTACTCCTCGAATGATCAACTGATACTTA'}]) def test_extract_seq(self): er.helper = Mock_Helper inters = er.extract_seq(self.example.gffs, self.example.seq, self.example.tsss, self.example.tas, 5, 300) self.assertDictEqual(inters[0], {'protein': 'AAA_00001', 'strain': 'aaa', 'start': 2, 'seq': 'AAAATTAT', 'end': 3, 'strand': '+'}) self.assertDictEqual(inters[1], {'protein': 'AAA_00001', 'strain': 'aaa', 'start': 1, 'seq': 'AAAATTAT', 'end': 3, 'strand': '+'})
def setUp(self): self.mock_args = MockClass() self.mock = Mock_func() self.mock_parser = Mock_Multiparser() self.example = Example() self.test_folder = "test_folder" self.trans = "test_folder/trans" self.out = "test_folder/output" self.gffs = "test_folder/gffs" self.tsss = "test_folder/tsss" self.terms = "test_folder/terms" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.trans) os.mkdir(os.path.join(self.trans, "tmp")) os.mkdir(self.out) os.mkdir(self.gffs) os.mkdir(self.tsss) os.mkdir(os.path.join(self.tsss, "tmp")) os.mkdir(self.terms) args = self.mock_args.mock() args.tsss = self.tsss args.trans = self.trans args.out_folder = self.out self.utr = UTRDetection(args)
class TestOptimizeTSS(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" self.fastas = os.path.join(self.test_folder, "fasta") self.wigs = os.path.join(self.test_folder, "wigs") self.gffs = os.path.join(self.test_folder, "gffs") self.manuals = os.path.join(self.test_folder, "manuals") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.fastas) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(self.wigs) os.mkdir(os.path.join(self.wigs, "tmp")) os.mkdir(self.gffs) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(self.manuals) os.mkdir(os.path.join(self.manuals, "tmp")) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_optimize_tss(self): opt.Helper = Mock_helper opt.Multiparser = Mock_multiparser opt.optimization = Mock_func().mock_optimization gen_file(os.path.join(self.gffs, "tmp", "test.gff"), "test") gen_file(os.path.join(self.fastas, "tmp", "test.fa"), "test") args = self.mock_args.mock() args.fastas = self.fastas args.gffs = self.gffs args.wigs = self.wigs args.tsspredator_path = "test" args.manuals = self.manuals gen_file(os.path.join(self.manuals, "tmp", "test.gff"), "test") args.output_folder = self.test_folder args.project_strain = "test" args.height = 9 args.height_reduction = 9 args.factor = 9 args.factor_reduction = 9 args.base_height = 9 args.enrichment = 9 args.processing = 9 args.utr = 200 args.libs = "test" args.replicate_name = "test" args.cluster = 2 args.strain_lengths = {"test": 100} args.cores = 4 args.program = "TSS" args.replicate = 2 args.steps = 2000 log = open(os.path.join(self.test_folder, "test.log"), "w") opt.optimize_tss(args, log) self.assertTrue(os.path.exists(os.path.join( self.test_folder, "test.csv"))) log.close()
def setUp(self): self.mock_args = MockClass() self.mock = Mock_func() self.mock_parser = Mock_Multiparser() self.example = Example() self.test_folder = "test_folder" self.trans = "test_folder/trans" self.out = "test_folder/output" self.wigs = "test_folder/wigs" self.gffs = "test_folder/gffs" self.tsss = "test_folder/tsss" self.fastas = "test_folder/fastas" self.manual = "test_folder/manuals" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.trans) os.mkdir(self.out) os.mkdir(self.wigs) os.mkdir(self.gffs) os.mkdir(self.tsss) os.mkdir(self.fastas) os.mkdir(self.manual) args = self.mock_args.mock() args.out_folder = self.out args.ta_files = self.trans args.gffs = self.gffs args.wig_folder = self.wigs args.fastas = self.fastas args.manual = self.manual self.tss = TSSpredator(args)
def setUp(self): self.mock = Mock_func() self.mock_args = MockClass() self.test_folder = "test_folder" self.tsss = "test_folder/tsss" self.srnas = "test_folder/sRNA" self.out = "test_folder/output" self.trans = "test_folder/trans" self.fastas = "test_folder/fastas" self.tex = "test_folder/tex" self.frag = "test_folder/frag" self.gffs = "test_folder/gffs" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.tsss) os.mkdir(self.out) os.mkdir(self.trans) os.mkdir(self.fastas) os.mkdir(self.tex) os.mkdir(self.frag) os.mkdir(self.srnas) os.mkdir(self.gffs) args = self.mock_args.mock() args.tsss = self.tsss args.srnas = self.srnas args.out_folder = self.out args.trans = self.trans args.fastas = self.fastas self.sorf = sORFDetection(args)
def setUp(self): self.converter = Converter() self.example = Example() self.converter.gff3parser = Mock_gff3_parser self.converter._print_rntptt_title = Mock_func().print_rntptt_title self.converter.tsspredator = Mock_TSSPredatorReader() self.converter._read_file = Mock_func().mock_read_file self.gff_file = self.example.gff_file self.ptt_out = self.example.ptt_out self.rnt_out = self.example.rnt_out self.srna_out = self.example.srna_out self.embl_file = self.example.embl_file self.embl_out = self.example.embl_out self.multi_embl = self.example.multi_embl self.gff_out = self.example.gff_out self.mastertable = self.example.mastertable self.tss_file = self.example.tss_file self.fasta_file = self.example.fasta_file self.transterm = self.example.transterm self.term_file = self.example.term_file self.circ_file = self.example.circrna_table self.circ_all = self.example.circrna_all self.circ_best = self.example.circrna_best self.test_folder = "test_folder" self.mock_args = MockClass() if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder)
def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" self.fasta = os.path.join(self.test_folder, "fasta") self.snp_folder = os.path.join(self.test_folder, "snp") self.table = os.path.join(self.test_folder, "table") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.fasta) os.mkdir(self.snp_folder) os.mkdir(self.table) os.mkdir(os.path.join( self.test_folder, "compare_related_and_reference_genomes")) os.mkdir(os.path.join( self.test_folder, "compare_related_and_reference_genomes/seqs")) os.mkdir(os.path.join( self.test_folder, "compare_related_and_reference_genomes/seqs/with_BAQ")) os.mkdir(os.path.join( self.test_folder, "compare_related_and_reference_genomes/statistics")) os.mkdir(os.path.join( self.test_folder, "compare_related_and_reference_genomes/SNP_raw_outputs")) args = self.mock_args.mock() args.types = "related_genome" args.out_folder = self.test_folder args.fastas = self.fasta self.snp = SNPCalling(args) self.mock = Mock_func()
def setUp(self): self.test_folder = "test_folder" self.mock_args = MockClass() self.mock = Mock_func() self.tsss = os.path.join(self.test_folder, "tsss") self.trans = os.path.join(self.test_folder, "trans") self.utr5s = os.path.join(self.test_folder, "utr5s") self.utr3s = os.path.join(self.test_folder, "utr3s") self.output = os.path.join(self.test_folder, "output") self.gffs = os.path.join(self.test_folder, "gffs") self.out_gff = os.path.join(self.output, "gffs") self.stat = os.path.join(self.test_folder, "stat") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.gffs) os.mkdir(self.tsss) os.mkdir(self.stat) os.mkdir(os.path.join(self.tsss, "tmp")) os.mkdir(self.trans) os.mkdir(os.path.join(self.trans, "tmp")) os.mkdir(self.utr5s) os.mkdir(os.path.join(self.utr5s, "tmp")) os.mkdir(self.utr3s) os.mkdir(os.path.join(self.utr3s, "tmp")) os.mkdir(self.output) os.mkdir(self.out_gff) os.mkdir(os.path.join(self.output, "tables")) args = self.mock_args.mock() args.tsss = self.tsss args.trans = self.trans args.utr5s = self.utr5s args.utr3s = self.utr3s args.output_folder = self.output args.terms = None self.operon = OperonDetection(args)
def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" self.ref_embls = "test_folder/embls" self.output_path = "test_folder/output" self.tar_fastas = "test_folder/tar_fasta" self.ref_fastas = "test_folder/ref_fasta" self.gff_outfolder = "test_folder/gffs" self.ref_gbk = "test_folder/gbk" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.ref_embls) os.mkdir(self.ref_gbk) os.mkdir(self.output_path) os.mkdir(self.tar_fastas) os.mkdir(self.ref_fastas) os.mkdir(self.gff_outfolder) args = self.mock_args.mock() args.output_path = self.output_path args.ref_embls = self.ref_embls args.ref_gbk = self.ref_gbk args.tar_fastas = self.tar_fastas args.ref_fastas = self.ref_fastas args.gff_outfolder = self.gff_outfolder self.ratt = RATT(args) self.example = Example()
def setUp(self): self.test_folder = "test_project" if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) os.mkdir(self.test_folder) self.example = Example() self.mock_args = MockClass()
def setUp(self): self.example = Example() self.mock = Mock_func() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder)
def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.test_folder = "test_folder" self.out = "test_folder/output" self.fastas = "test_folder/fastas" self.gffs = "test_folder/gffs" self.stat = "test_folder/stat" self.trans = "test_folder/tran" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.out) os.mkdir(self.fastas) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(self.gffs) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(self.stat) os.mkdir(self.trans) args = self.mock_args.mock() args.gffs = self.gffs args.fastas = self.fastas args.out_folder = self.out args.trans = self.trans self.sub = SubLocal(args)
def setUp(self): self.mock_args = MockClass() self.example = Example() self.mock = Mock_func() self.test_folder = "test_folder" self.gffs = "test_folder/gffs" self.srnas = "test_folder/srnas" self.out = "test_folder/output" self.fastas = "test_folder/fastas" self.seq = "test_folder/output/sRNA_seqs" self.rnaup = "test_folder/output/RNAup" self.rnaplex = "test_folder/output/RNAplex" self.merge = "test_folder/output/merge" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.gffs) os.mkdir(self.out) os.mkdir(self.srnas) os.mkdir(self.fastas) os.mkdir(self.rnaup) os.mkdir(self.rnaplex) os.mkdir(self.seq) os.mkdir(self.merge) os.mkdir(os.path.join(self.rnaup, "test")) args = self.mock_args.mock() args.out_folder = self.out args.srnas = self.srnas args.fastas = self.fastas args.gffs = self.gffs self.star = sRNATargetPrediction(args)
def setUp(self): self.segemehl = Mock_segemehl() self.samtools = Mock_samtools() self.mock_args = MockClass() self.example = Example() self.test_folder = "test_folder" self.fasta_folder = os.path.join(self.test_folder, "fasta") self.gff_folder = os.path.join(self.test_folder, "gff") self.out_folder = os.path.join(self.test_folder, "output") self.read_folder = os.path.join(self.test_folder, "read") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) if (not os.path.exists(self.fasta_folder)): os.mkdir(self.fasta_folder) os.mkdir(os.path.join(self.fasta_folder, "tmp")) if (not os.path.exists(self.gff_folder)): os.mkdir(self.gff_folder) if (not os.path.exists(self.out_folder)): os.mkdir(self.out_folder) if (not os.path.exists(self.read_folder)): os.mkdir(self.read_folder) args = self.mock_args.mock() args.output_folder = self.out_folder args.gffs = self.gff_folder args.align = True args.fastas = self.fasta_folder self.circ = CircRNADetection(args)
class TestMEME(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" self.out_folder = "test_folder/output" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.out_folder) os.mkdir(os.path.join(self.out_folder, "fasta_output")) self.tss_folder = os.path.join(self.test_folder, "tss_folder") if (not os.path.exists(self.tss_folder)): os.mkdir(self.tss_folder) self.gff_folder = os.path.join(self.test_folder, "gff_folder") if (not os.path.exists(self.gff_folder)): os.mkdir(self.gff_folder) self.fa_folder = os.path.join(self.test_folder, "fa_folder") if (not os.path.exists(self.fa_folder)): os.mkdir(self.fa_folder) args = self.mock_args.mock() args.tsss = self.tss_folder args.fastas = self.fa_folder args.gffs = self.gff_folder args.output_folder = self.out_folder self.meme = MEME(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_move_and_merge_fasta(self): me.del_repeat_fasta = Mock_func().mock_del_repeat_fasta if (not os.path.exists("tmp")): os.mkdir("tmp") gen_file("tmp/primary.fa", "primary") gen_file("tmp/secondary.fa", "secondary") gen_file("tmp/internal.fa", "internal") gen_file("tmp/antisense.fa", "antisense") gen_file("tmp/orphan.fa", "orphan") self.meme._move_and_merge_fasta(self.test_folder, "test") self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test_allstrain_all_types.fa"))) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test_allstrain_primary.fa"))) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test_allstrain_secondary.fa"))) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test_allstrain_internal.fa"))) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test_allstrain_antisense.fa"))) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test_allstrain_orphan.fa"))) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test_allstrain_without_orphan.fa"))) def test_split_fasta_by_strain(self): with open(os.path.join(self.fa_folder, "allstrain.fa"), "w") as fh: fh.write(""">aaa_aaa_aaa ATTATATATA >bbb_bbb_bbb AATTAATTAA""") self.meme._split_fasta_by_strain(self.fa_folder) self.assertTrue(os.path.join(self.fa_folder, "aaa.fa")) self.assertTrue(os.path.join(self.fa_folder, "bbb.fa"))
class TestPotentialTarget(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_read_file(self): seq_file = os.path.join(self.test_folder, "seq") gff_file = os.path.join(self.test_folder, "gff") gen_file(seq_file, self.example.seq_file) gen_file(gff_file, self.example.gff_file) fasta, cdss_f, cdss_r, genes = pt.read_file( seq_file, gff_file, "test", ["CDS"]) self.assertEqual( fasta, "AGGATAGTCCGATACGTATACTGATAAAGACCGAAAATATTAGCGCGTAGC") self.assertEqual(cdss_f[0].start, 1) self.assertEqual(cdss_f[0].feature, "CDS") self.assertEqual(cdss_r[0].start, 14) self.assertEqual(cdss_r[0].feature, "CDS") self.assertEqual(len(genes), 2) self.assertEqual(genes[0].start, 1) self.assertEqual(genes[1].start, 14) def test_deal_cds_forward(self): pt.deal_cds_forward(self.example.cdss_f, self.test_folder, self.example.fasta, self.example.genes, 2, 10) data = import_data(os.path.join(self.test_folder, "aaa_target.fa")) self.assertTrue("\n".join(data), self.example.cdsf_result) def test_deal_cds_reverse(self): pt.deal_cds_reverse(self.example.cdss_r, self.test_folder, self.example.fasta, self.example.genes, 2, 10) data = import_data(os.path.join(self.test_folder, "aaa_target.fa")) self.assertTrue("\n".join(data), self.example.cdsf_result) def test_potential_target(self): seq_file = os.path.join(self.test_folder, "seq") gff_file = os.path.join(self.test_folder, "gff") gen_file(seq_file, self.example.seq_file) gen_file(gff_file, self.example.gff_file) args = self.mock_args.mock() args.tar_start = 2 args.tar_end = 10 args.features = ["CDS"] pt.potential_target(gff_file, seq_file, self.test_folder, args) data = import_data(os.path.join(self.test_folder, "aaa_target.fa")) self.assertTrue("\n".join(data), self.example.all_result)
class TestGetPolyT(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) self.gffs = os.path.join(self.test_folder, "gff_folder") if (not os.path.exists(self.gffs)): os.mkdir(self.gffs) self.go_folder = os.path.join(self.test_folder, "go_folder") if (not os.path.exists(self.go_folder)): os.mkdir(self.go_folder) self.all_strain = "all_genomes_uniprot.csv" self.trans = os.path.join(self.test_folder, "tran_folder") if (not os.path.exists(self.trans)): os.mkdir(self.trans) args = self.mock_args.mock() args.out_folder = self.test_folder args.gffs = self.gffs args.trans = self.trans self.go = GoTermFinding(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_merge_files(self): gff_folder = os.path.join(self.gffs, "test.gff_folder") if (not os.path.exists(gff_folder)): os.mkdir(gff_folder) test1_folder = os.path.join(self.go_folder, "test1") if (not os.path.exists(test1_folder)): os.mkdir(test1_folder) test2_folder = os.path.join(self.go_folder, "test2") if (not os.path.exists(test2_folder)): os.mkdir(test2_folder) with open(os.path.join(gff_folder, "test1.gff"), "w") as fh: fh.write("test1") with open(os.path.join(gff_folder, "test2.gff"), "w") as fh: fh.write("test2") with open(os.path.join(test1_folder, "test1_uniprot.csv"), "w") as fh: fh.write("test1") with open(os.path.join(test2_folder, "test2_uniprot.csv"), "w") as fh: fh.write("test2") log = open(os.path.join(self.test_folder, "test.log"), "w") self.go._merge_files(self.gffs, self.go_folder, self.test_folder, log) out_file = os.path.join(self.go_folder, "test", self.all_strain) self.assertTrue(os.path.exists(out_file)) data = [] with open(out_file) as fh: for line in fh: data.append(line) self.assertEqual("".join(data), "Genome Strand Start End Protein_id Go_term\ntest1\ntest2\n") log.close()
def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.test_folder = "test_folder" self.fasta = "test_folder/fasta" self.wigs = "test_folder/wig" self.gff = "test_folder/gff" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.fasta) os.mkdir(self.wigs) os.mkdir(self.gff)
class TestGetPolyT(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) self.gffs = os.path.join(self.test_folder, "gff_folder") if (not os.path.exists(self.gffs)): os.mkdir(self.gffs) self.go_folder = os.path.join(self.test_folder, "go_folder") if (not os.path.exists(self.go_folder)): os.mkdir(self.go_folder) self.all_strain = "all_strains_uniprot.csv" self.trans = os.path.join(self.test_folder, "tran_folder") if (not os.path.exists(self.trans)): os.mkdir(self.trans) args = self.mock_args.mock() args.out_folder = self.test_folder args.gffs = self.gffs args.trans = self.trans self.go = GoTermFinding(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_merge_files(self): gff_folder = os.path.join(self.gffs, "test.gff_folder") if (not os.path.exists(gff_folder)): os.mkdir(gff_folder) test1_folder = os.path.join(self.go_folder, "test1") if (not os.path.exists(test1_folder)): os.mkdir(test1_folder) test2_folder = os.path.join(self.go_folder, "test2") if (not os.path.exists(test2_folder)): os.mkdir(test2_folder) with open(os.path.join(gff_folder, "test1.gff"), "w") as fh: fh.write("test1") with open(os.path.join(gff_folder, "test2.gff"), "w") as fh: fh.write("test2") with open(os.path.join(test1_folder, "test1_uniprot.csv"), "w") as fh: fh.write("test1") with open(os.path.join(test2_folder, "test2_uniprot.csv"), "w") as fh: fh.write("test2") self.go._merge_files(self.gffs, self.go_folder, self.test_folder) out_file = os.path.join(self.go_folder, "test", self.all_strain) self.assertTrue(os.path.exists(out_file)) with open(out_file) as fh: for line in fh: self.assertEqual(line, "test1test2")
def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" self.fastas = os.path.join(self.test_folder, "fasta") self.wigs = os.path.join(self.test_folder, "wigs") self.gffs = os.path.join(self.test_folder, "gffs") self.manuals = os.path.join(self.test_folder, "manuals") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.fastas) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(self.wigs) os.mkdir(os.path.join(self.wigs, "tmp")) os.mkdir(self.gffs) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(self.manuals) os.mkdir(os.path.join(self.manuals, "tmp"))
def setUp(self): self.test_folder = "test_folder" self.mock_args = MockClass() if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(os.path.join(self.test_folder, "tmp_id_list")) # os.mkdir(os.path.join(self.test_folder, "tmp_nospecific")) os.mkdir(os.path.join(self.test_folder, "with_strain")) os.mkdir(os.path.join(self.test_folder, "with_strain/test_ptt")) os.mkdir(os.path.join(self.test_folder, "without_strain")) os.mkdir(os.path.join(self.test_folder, "without_strain/test_ptt")) os.mkdir(os.path.join(self.test_folder, "all_results")) os.mkdir(os.path.join(self.test_folder, "best_results")) os.mkdir(os.path.join(self.test_folder, "figures")) self.ppi = PPINetwork(self.test_folder) self.mock = Mock_func() self.example = Example()
def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.test_folder = "test_folder" self.gffs = os.path.join(self.test_folder, "gffs") self.fastas = os.path.join(self.test_folder, "fastas") self.out_folder = os.path.join(self.test_folder, "output") self.database = os.path.join(self.test_folder, "database") self.seq_path = os.path.join(self.test_folder, "seqs") self.tables = os.path.join(self.out_folder, "tables") self.stat = os.path.join(self.out_folder, "statistics") self.scan = os.path.join(self.test_folder, "scan") self.tsss = os.path.join(self.test_folder, "tsss") self.trans = os.path.join(self.test_folder, "trans") self.out_gff = os.path.join(self.out_folder, "gffs") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.tsss) os.mkdir(os.path.join(self.tsss, "tmp")) os.mkdir(self.trans) os.mkdir(os.path.join(self.trans, "tmp")) os.mkdir(self.gffs) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(self.fastas) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(self.out_folder) os.mkdir(self.database) os.mkdir(self.seq_path) os.mkdir(os.path.join(self.out_folder, "tmp_table")) os.mkdir(os.path.join(self.out_folder, "tmp_scan")) os.mkdir(os.path.join(self.out_folder, "tmp_fasta")) os.mkdir(os.path.join(self.out_folder, "scan_Rfam")) os.mkdir(self.tables) os.mkdir(self.scan) os.mkdir(self.stat) os.mkdir(self.out_gff) args = self.mock_args.mock() args.gffs = self.gffs args.fastas = self.fastas args.ribos_out_folder = self.out_folder args.database = self.database args.tsss = self.tsss args.trans = self.trans args.program = 'riboswtich' self.ribo = Ribos(args)
def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" self.output = os.path.join(self.test_folder, "output") self.tex_wig = os.path.join(self.test_folder, "tex") self.frag_wig = os.path.join(self.test_folder, "frag") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.tex_wig) os.mkdir(self.frag_wig) os.mkdir(self.output) self.fasta = os.path.join(self.test_folder, "aaa.fa") gen_file(self.fasta, self.example.fasta) args = self.mock_args.mock() args.output_folder = self.output args.fasta = self.fasta self.screen = Screen(args, self.output)
def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) self.gffs = os.path.join(self.test_folder, "gff_folder") if (not os.path.exists(self.gffs)): os.mkdir(self.gffs) self.go_folder = os.path.join(self.test_folder, "go_folder") if (not os.path.exists(self.go_folder)): os.mkdir(self.go_folder) self.all_strain = "all_genomes_uniprot.csv" self.trans = os.path.join(self.test_folder, "tran_folder") if (not os.path.exists(self.trans)): os.mkdir(self.trans) args = self.mock_args.mock() args.out_folder = self.test_folder args.gffs = self.gffs args.trans = self.trans self.go = GoTermFinding(args)
def setUp(self): self.mock_args = MockClass() self.example = Example() self.mock = Mock_func() self.test_folder = "test_folder" self.gffs = "test_folder/gffs" self.tsss = "test_folder/tsss" self.sorf = "test_folder/sORF" self.out = "test_folder/output" self.trans = "test_folder/trans" self.fastas = "test_folder/fastas" self.tex = "test_folder/tex" self.frag = "test_folder/frag" self.pros = "test_folder/pros" self.terms = "test_folder/terms" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.gffs) os.mkdir(self.tsss) os.mkdir(os.path.join(self.tsss, "tmp")) os.mkdir(self.out) os.mkdir(self.trans) os.mkdir(os.path.join(self.trans, "tmp")) os.mkdir(self.fastas) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(self.tex) os.mkdir(self.frag) os.mkdir(self.pros) os.mkdir(os.path.join(self.pros, "tmp")) os.mkdir(self.sorf) os.mkdir(os.path.join(self.sorf, "tmp")) os.mkdir(self.terms) args = self.mock_args.mock() args.tss_folder = self.tsss args.pro_folder = self.pros args.out_folder = self.out args.sorf_file = self.sorf args.fastas = self.fastas args.trans = self.trans args.terms = self.terms self.srna = sRNADetection(args)
def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" self.out_folder = "test_folder/output" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.out_folder) os.mkdir(os.path.join(self.out_folder, "fasta_output")) self.tss_folder = os.path.join(self.test_folder, "tss_folder") if (not os.path.exists(self.tss_folder)): os.mkdir(self.tss_folder) self.gff_folder = os.path.join(self.test_folder, "gff_folder") if (not os.path.exists(self.gff_folder)): os.mkdir(self.gff_folder) self.fa_folder = os.path.join(self.test_folder, "fa_folder") if (not os.path.exists(self.fa_folder)): os.mkdir(self.fa_folder) args = self.mock_args.mock() args.tsss = self.tss_folder args.fastas = self.fa_folder args.gffs = self.gff_folder args.output_folder = self.out_folder self.meme = MEME(args)
def setUp(self): self.example = Example() self.mock_args = MockClass()
class TestCoverageDetection(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() def test_coverage_comparison_first(self): first = True cover_sets = {"high": -1, "low": -1} poss = {"high": -1, "low": -1} cover = 100 cover_detect.coverage_comparison(cover, cover_sets, poss, first, "+", 50) self.assertDictEqual(cover_sets, {"high": 100, "low": 100}) self.assertDictEqual(poss, {"high": 50, "low": 50}) def test_coverage_comparison_forward(self): first = False cover_sets = {"high": 50, "low": 20} poss = {"high": 10, "low": 30} cover = 100 cover_detect.coverage_comparison(cover, cover_sets, poss, first, "+", 50) self.assertDictEqual(cover_sets, {"high": 100, "low": 100}) self.assertDictEqual(poss, {"high": 50, "low": 50}) cover = 30 cover_detect.coverage_comparison(cover, cover_sets, poss, first, "+", 51) self.assertDictEqual(cover_sets, {"high": 100, "low": 30}) self.assertDictEqual(poss, {"high": 50, "low": 51}) def test_coverage_comparison_reverse(self): first = False cover_sets = {"high": 50, "low": 20} poss = {"high": 30, "low": 10} cover = 100 cover_detect.coverage_comparison(cover, cover_sets, poss, first, "-", 50) self.assertDictEqual(cover_sets, {"high": 100, "low": 100}) self.assertDictEqual(poss, {"high": 50, "low": 50}) cover = 30 cover_detect.coverage_comparison(cover, cover_sets, poss, first, "-", 49) self.assertDictEqual(cover_sets, {"high": 100, "low": 30}) self.assertDictEqual(poss, {"high": 50, "low": 49}) def test_define_cutoff_median(self): coverages = {"3utr": "mean", "5utr": "median"} median = { "track_a": { "median": 100, "mean": 200 }, "track_b": { "median": 30, "mean": 80 } } cutoff = cover_detect.define_cutoff(coverages, median, "5utr") self.assertDictEqual(cutoff, {'track_a': 100, 'track_b': 30}) cutoff = cover_detect.define_cutoff(coverages, median, "3utr") self.assertDictEqual(cutoff, {'track_a': 200, 'track_b': 80}) def test_check_tex(self): template_texs = self.example.texs covers = self.example.cover_datas coverages = {"3utr": 100, "5utr": 600} poss = {"high": 30, "low": 10} median = { "track1_tex": { "median": 100, "mean": 200 }, "track1_notex": { "median": 30, "mean": 80 }, "track2_tex": { "median": 150, "mean": 200 }, "track2_notex": { "median": 10, "mean": 20 }, "frag": { "median": 80, "mean": 100 } } target_datas = [] texs = { "track1_tex@AND@track1_notex": 0, "track2_tex@AND@track2_notex": 0 } detect_num_lib = cover_detect.check_tex(template_texs, covers, target_datas, 20, None, poss, median, coverages, "3utr", 200, 2) self.assertEqual(detect_num_lib, 2) num_frag = 0 num_tex = 0 for target in target_datas: if target["type"] == "frag": num_frag += 1 else: num_tex += 1 self.assertEqual(num_frag, 1) self.assertEqual(num_tex, 2) detect_num_lib = cover_detect.check_tex(template_texs, covers, target_datas, 20, "sRNA_utr_derived", poss, median, coverages, "5utr", 200, 2) self.assertEqual(detect_num_lib, 2) self.assertDictEqual(poss, { 'start': 100, 'high': 30, 'end': 202, 'low': 10 }) def test_replicate_comparison(self): cover_detect.check_tex = Mock_func().mock_check_tex template_texs = self.example.texs srna_covers = {"texnotex": self.example.cover_datas} coverages = {"3utr": 100, "5utr": 600} median = { "track1_tex": { "median": 100, "mean": 200 }, "track1_notex": { "median": 30, "mean": 80 }, "track2_tex": { "median": 150, "mean": 200 }, "track2_notex": { "median": 10, "mean": 20 }, "frag": { "median": 80, "mean": 100 } } texs = { "track1_tex@AND@track1_notex": 0, "track2_tex@AND@track2_notex": 0 } args = self.mock_args.mock() args.replicates = {"tex": "all_2", "frag": "all_1"} args.tex_notex = 2 srna_datas = cover_detect.replicate_comparison(args, srna_covers, "+", "sRNA_utr_derived", median, coverages, "3utr", 100, 200, template_texs) self.assertEqual(srna_datas["best"], 500) self.assertEqual(srna_datas["track"], "frag") self.assertEqual(srna_datas["high"], 700) self.assertEqual(srna_datas["low"], 400) self.assertEqual(srna_datas["start"], 100) self.assertEqual(srna_datas["end"], 202)
class TestScreen(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" self.output = os.path.join(self.test_folder, "output") self.tex_wig = os.path.join(self.test_folder, "tex") self.frag_wig = os.path.join(self.test_folder, "frag") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.tex_wig) os.mkdir(self.frag_wig) os.mkdir(self.output) self.fasta = os.path.join(self.test_folder, "aaa.fa") gen_file(self.fasta, self.example.fasta) args = self.mock_args.mock() args.output_folder = self.output args.fasta = self.fasta self.screen = Screen(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_screenshot(self): gen_file(os.path.join(self.tex_wig, "tex_1_f.wig"), self.example.wig_f) gen_file(os.path.join(self.tex_wig, "notex_1_f.wig"), self.example.wig_f) gen_file(os.path.join(self.frag_wig, "frag_f.wig"), self.example.wig_f) gen_file(os.path.join(self.tex_wig, "tex_1_r.wig"), self.example.wig_r) gen_file(os.path.join(self.tex_wig, "notex_1_r.wig"), self.example.wig_r) gen_file(os.path.join(self.frag_wig, "frag_r.wig"), self.example.wig_r) args = self.mock_args.mock() args.fasta = self.fasta args.main_gff = os.path.join(self.test_folder, "main.gff") gen_file(args.main_gff, self.example.main_gff) side_gff = os.path.join(self.test_folder, "side.gff") args.side_gffs = [side_gff] gen_file(side_gff, self.example.side_gff) args.frag_wigs = self.frag_wig args.tex_wigs = self.tex_wig args.height = 1000 args.tlibs = [ "test_folder/tex/tex_1_f.wig:tex:1:a:+", "test_folder/tex/tex_1_r.wig:tex:1:a:-", "test_folder/tex/notex_1_f.wig:notex:1:a:+", "test_folder/tex/notex_1_r.wig:notex:1:a:-" ] args.flibs = [ "test_folder/frag/frag_f.wig:frag:1:a:+", "test_folder/frag/frag_r.wig:frag:1:a:-" ] args.present = "expand" args.output_folder = self.output self.screen.screenshot(args) self.assertTrue( os.path.exists( os.path.join(self.output, "screenshots", "aaa", "forward"))) self.assertTrue( os.path.exists( os.path.join(self.output, "screenshots", "aaa", "reverse"))) datas = import_data( os.path.join(self.output, "screenshots", "aaa", "forward.txt")) datas = import_data( os.path.join(self.output, "screenshots", "aaa", "reverse.txt")) self.assertEqual("\n".join(datas), self.example.out_r) def test_import_libs(self): texs = [[ os.path.join(self.tex_wig, "tex_1.wig"), "tex", "1", "a", "+" ], [os.path.join(self.tex_wig, "notex_1.wig"), "notex", "1", "a", "+"]] lib_dict = {"ft": [], "fn": [], "rt": [], "rn": [], "ff": [], "rf": []} self.screen._import_libs(texs, "+", lib_dict) self.assertDictEqual( lib_dict, { 'fn': ['test_folder/tex/notex_1.wig'], 'rn': [], 'rt': [], 'ft': ['test_folder/tex/tex_1.wig'], 'rf': [], 'ff': [] })
class TestsTranscriptAssembly(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.mock = Mock_func() self.mock_parser = Mock_Multiparser() self.example = Example() self.test_folder = "test_folder" self.trans = "test_folder/trans" self.out = "test_folder/output" self.tex = "test_folder/tex" self.frag = "test_folder/frag" self.gffs = "test_folder/gffs" self.tsss = "test_folder/tsss" self.terms = "test_folder/terms" self.stat = "test_folder/output/statistics" self.out_gff = "test_folder/output/gffs" self.out_table = "test_folder/output/tables" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.trans) os.mkdir(self.out) os.mkdir(self.tex) os.mkdir(self.frag) os.mkdir(os.path.join(self.frag, "tmp")) os.mkdir(self.gffs) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(self.tsss) os.mkdir(self.terms) os.mkdir(self.stat) os.mkdir(self.out_gff) os.mkdir(self.out_table) args = self.mock_args.mock() args.out_folder = self.out self.tran = TranscriptDetection(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_compute(self): pre_assembly = tr.detect_transcript tr.detect_transcript = self.mock.mock_assembly gen_file(os.path.join(self.frag, "tmp/test_forward.wig"), "test") args = self.mock_args.mock() args.replicates = "rep" args.out_foler = self.out strains = self.tran._compute("frag", self.frag, "libs", args) self.assertListEqual(strains, ['test']) tr.assembly = pre_assembly def test_for_one_wig(self): pre_assembly = tr.assembly tr.assembly = self.mock.mock_assembly self.tran.multiparser = self.mock_parser gen_file(os.path.join(self.frag, "tmp/test_forward.wig"), "test") gen_file(os.path.join(self.out, "test_frag"), self.example.tran_file) args = self.mock_args.mock() args.replicates = "rep" args.libs = "libs" args.gffs = self.gffs args.out_folder = self.out args.frag_wigs = self.frag args.flibs = "flibs" strains = self.tran._for_one_wig("frag", args) self.assertListEqual(strains, ['test']) datas = import_data( os.path.join(self.out_gff, "test_transcript_frag.gff")) self.assertEqual("\n".join(datas), "##gff-version 3\n" + self.example.tran_file) tr.assembly = pre_assembly def test_for_two_wigs(self): pre_combine = tr.combine tr.combine = self.mock.mock_combine gen_file(os.path.join(self.out_gff, "test_transcript_fragment.gff"), "test") gen_file(os.path.join(self.out_gff, "test_transcript_tex_notex.gff"), "test") args = self.mock_args.mock() args.frag_wigs = self.frag args.tex_wigs = self.tex args.gffs = self.gffs args.tolerance = 5 log = open(os.path.join(self.test_folder, "test.log"), "w") self.tran._for_two_wigs(["test"], args, log) self.assertTrue( os.path.exists(os.path.join(self.out_gff, "test_transcript.gff"))) tr.combine = pre_combine def test_post_modify(self): pre_longer = tr.longer_ta pre_fill = tr.fill_gap tr.longer_ta = self.mock.mock_longer_ta tr.fill_gap = self.mock.mock_fill_gap gen_file(os.path.join(self.gffs, "test.gff"), self.example.gff_file) gff_out = os.path.join(self.out, "gffs") os.mkdir(os.path.join(self.out, "tmp_tran")) gen_file(os.path.join(gff_out, "tmp_uni"), self.example.tran_file) gen_file(os.path.join(gff_out, "tmp_overlap"), self.example.tran_file) gen_file(os.path.join(gff_out, "final_test"), self.example.tran_file) args = self.mock_args.mock() args.gffs = self.gffs args.out_folder = self.out args.length = 20 args.modify = "merge_overlap" self.tran._post_modify(["test"], args) self.assertTrue( os.path.exists(os.path.join(gff_out, "test_transcript.gff"))) tr.longer_ta = pre_longer tr.fill_gap = pre_fill def test_compare_cds(self): tr.stat_ta_gff = self.mock.mock_stat_ta_gff self.tran.multiparser = self.mock_parser gen_file(os.path.join(self.gffs, "test.gff"), self.example.gff_file) gen_file(os.path.join(self.gffs, "tmp/test.gff"), self.example.gff_file) gen_file(os.path.join(self.out_gff, "test_transcript.gff"), self.example.tran_file) gff_out = os.path.join(self.out, "gffs") gen_file(os.path.join(gff_out, "tmp_ta_gff"), self.example.tran_file) gen_file(os.path.join(gff_out, "tmp_gff_ta"), self.example.gff_file) args = self.mock_args.mock() args.out_folder = self.out args.trans = self.trans args.gffs = self.gffs log = open(os.path.join(self.test_folder, "test.log"), "w") args.c_feature = ["CDS"] self.tran._compare_cds(["test"], args, log) datas = import_data(os.path.join(self.gffs, "test.gff")) self.assertEqual("\n".join(datas), "##gff-version 3\n" + self.example.gff_file) datas = import_data(os.path.join(self.out_gff, "test_transcript.gff")) self.assertEqual("\n".join(datas), "##gff-version 3\n" + self.example.tran_file) def test_compare_tss(self): tr.stat_ta_tss = self.mock.mock_stat_ta_tss self.tran.multiparser = self.mock_parser gen_file(os.path.join(self.gffs, "test_TSS.gff"), self.example.gff_file) gen_file(os.path.join(self.gffs, "tmp/test_TSS.gff"), self.example.gff_file) gen_file(os.path.join(self.out_gff, "test_transcript.gff"), self.example.tran_file) gff_out = os.path.join(self.out, "gffs") gen_file(os.path.join(gff_out, "tmp_ta_tss"), self.example.tran_file) gen_file(os.path.join(gff_out, "tmp_tss_ta"), self.example.gff_file) args = self.mock_args.mock() args.out_folder = self.out args.trans = self.trans args.compare_tss = self.gffs args.fuzzy = 2 log = open(os.path.join(self.test_folder, "test.log"), "w") self.tran._compare_tss(["test"], args, log) datas = import_data(os.path.join(self.gffs, "test_TSS.gff")) self.assertEqual("\n".join(datas), "##gff-version 3\n" + self.example.gff_file) datas = import_data(os.path.join(self.out_gff, "test_transcript.gff")) self.assertEqual("\n".join(datas), "##gff-version 3\n" + self.example.tran_file) def test_run_transcript_assembly(self): tr.stat_ta_tss = self.mock.mock_stat_ta_tss tr.stat_ta_gff = self.mock.mock_stat_ta_gff tr.longer_ta = self.mock.mock_longer_ta tr.fill_gap = self.mock.mock_fill_gap tr.combine = self.mock.mock_combine pre_assembly = tr.detect_transcript tr.assembly = self.mock.mock_assembly tr.gen_table_transcript = self.mock.mock_gen_table_tran gen_file(os.path.join(self.frag, "tmp/test1_forward.wig"), self.example.wig_f) gen_file(os.path.join(self.frag, "tmp/test1_reverse.wig"), self.example.wig_r) gen_file(os.path.join(self.gffs, "test.gff"), self.example.gff_file) gen_file(os.path.join(self.tsss, "test_TSS.gff"), self.example.tss_file) gen_file(os.path.join(self.terms, "test_term.gff"), self.example.term_file) gen_file("test_folder/output/test1_fragment", self.example.tran_file) gff_out = os.path.join(self.out, "gffs") gen_file( os.path.join(gff_out, "test_transcript_assembly_fragment.gff"), self.example.tran_file) gen_file(os.path.join(gff_out, "tmp_uni"), self.example.tran_file) gen_file(os.path.join(gff_out, "tmp_overlap"), self.example.tran_file) gen_file(os.path.join(gff_out, "final_test"), self.example.tran_file) args = self.mock_args.mock() args.out_folder = self.out args.frag_wigs = self.frag args.tex_wigs = None args.flibs = "flibs" args.tlibs = "tlibs" args.gffs = self.gffs args.terms = None args.compare_tss = None args.c_feature = None args.fuzzy_term = 1 args.max_dist = 2000 args.modify = "merge_overlap" log = open(os.path.join(self.test_folder, "test.log"), "w") self.tran.run_transcript(args, log) tr.assembly = pre_assembly
class TestSubLocal(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.test_folder = "test_folder" self.out = "test_folder/output" self.fastas = "test_folder/fastas" self.gffs = "test_folder/gffs" self.stat = "test_folder/stat" self.trans = "test_folder/tran" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.out) os.mkdir(self.fastas) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(self.gffs) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(self.stat) os.mkdir(self.trans) args = self.mock_args.mock() args.gffs = self.gffs args.fastas = self.fastas args.out_folder = self.out args.trans = self.trans self.sub = SubLocal(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_get_protein_seq(self): gen_file(os.path.join(self.fastas, "tmp/aaa.fa"), self.example.fasta_file) gff = "aaa.gff" gen_file(os.path.join(self.gffs, "tmp", gff), self.example.gff_file) gen_file(os.path.join(self.trans, "aaa_transcript.gff"), self.example.tran_file) prefix = self.sub._get_protein_seq(gff, self.test_folder, self.trans) self.assertEqual(prefix, "aaa") def test_run_psortb(self): self.sub._psortb = self.mock.mock_psortb tmp_result = os.path.join(self.out, "tmp_results") os.mkdir(tmp_result) args = self.mock_args.mock() args.psortb_path = "psortb_path" args.gram = "positive" self.sub._run_psortb(args, "aaa", self.out, self.test_folder, tmp_result) self.assertTrue(os.path.exists(os.path.join(self.out, "tmp_log"))) self.assertTrue( os.path.exists( os.path.join(tmp_result, "_".join(["aaa", "raw.txt"])))) def test_merge_and_stat(self): su.stat_sublocal = self.mock.mock_stat_sublocal os.mkdir(os.path.join(self.gffs, "aaa.gff_folder")) gen_file(os.path.join(self.gffs, "aaa.gff_folder/aaa.gff"), "test") os.mkdir(os.path.join(self.out, "psortb_results")) gen_file(os.path.join(self.out, "aaa_raw.txt"), "test") gen_file(os.path.join(self.out, "aaa_table.csv"), "test") self.sub._merge_and_stat(self.gffs, self.out, self.test_folder, self.stat) self.assertTrue(os.path.exists(os.path.join(self.stat, "aaa"))) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "aaa"))) def test_compare_cds_tran(self): gff_file = os.path.join(self.test_folder, "aaa.gff") tran_file = os.path.join(self.test_folder, "aaa_transcript.gff") gen_file(gff_file, self.example.gff_file) gen_file(tran_file, self.example.tran_file) self.sub._compare_cds_tran(gff_file, tran_file) datas, string = extract_info("test_folder/output/all_CDSs/tmp_cds.gff", "file") self.assertEqual("\n".join(datas), 'aaa\tRefSeq\tCDS\t3\t17\t.\t+\t.')
class TestMergeRNAplexRNAup(unittest.TestCase): def setUp(self): self.test_folder = "test_project" if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) os.mkdir(self.test_folder) self.example = Example() self.mock_args = MockClass() def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_detect_energy(self): srna = {"energy": -2} mrr.detect_energy(self.example.out_rna_txt, srna) self.assertDictEqual(srna, {'energy': -5.3}) srna = {"energy": -8} mrr.detect_energy(self.example.out_rna_txt, srna) self.assertDictEqual(srna, {'energy': -8.0}) def test_print_rank_one(self): out = StringIO() args_tar = self.mock_args.mock() args_tar.top = 2 args_tar.tar_start = 20 args_tar.tar_end = 15 mrr.print_rank_one(self.example.srnas, out, "RNAplex", self.example.gffs, self.example.srna_gffs, args_tar, 50) datas = convert_dict(out.getvalue().split("\n")) news = {} for key, value in datas.items(): if len(key) != 0: news[key] = value refs = convert_dict(self.example.out_print.split("\n")) self.assertDictEqual(news, refs) def test_read_table(self): rnaplex = os.path.join(self.test_folder, "rnaplex") rnaup = os.path.join(self.test_folder, "rnaup") gen_file(rnaplex, self.example.rnaplex) gen_file(rnaup, self.example.rnaup) srnas = mrr.read_table(self.example.srna_gffs, rnaplex, rnaup, None, self.example.genes, self.example.gffs, ["CDS"]) self.assertDictEqual( srnas, { 'IntaRNA': {}, 'RNAup': { 'srna0': [{ 'srna_pos': '20,25', 'energy': -4.87, 'tar_pos': '571,576', 'gene_id': 'gene0', 'target_id': 'cds0', 'target_locus': 'AAA_00001', 'detail': '100-150_+' }, { 'srna_pos': '11,26', 'energy': -5.91, 'tar_pos': '14,30', 'gene_id': 'NA', 'target_id': 'cds1', 'target_locus': 'AAA_00003', 'detail': '2348-2934_+' }] }, 'RNAplex': { 'srna0': [{ 'srna_pos': '20,25', 'energy': -5.3, 'tar_pos': '571,576', 'gene_id': 'gene0', 'target_id': 'cds0', 'target_locus': 'AAA_00001', 'detail': '100-150_+' }], 'srna1': [{ 'srna_pos': '24,31', 'energy': -1.91, 'tar_pos': '163,170', 'gene_id': 'gene0', 'target_id': 'cds0', 'target_locus': 'AAA_00001', 'detail': '100-150_+' }] } }) def test_get_srna_name(self): output = mrr.get_srna_name(self.example.srna_gffs, "srna0") self.assertEqual(output[0], 'sRNA_0') self.assertEqual(output[1].start, 6) def test_get_target_info(self): target = { "gene_id": "gene0", "detail": "100-150_+", "target_id": "cds0", "target_locus": "AAA_00001", "energy": -6.5 } output = mrr.get_target_info(self.example.gffs, target) self.assertEqual(output.start, 100) def test_merge_result(self): args_tar = self.mock_args.mock() args_tar.top = 2 args_tar.tar_start = 20 args_tar.tar_end = 15 merges = [] methods = ["RNAup", "RNAplex"] overlap = mrr.merge_result(self.example.srnas, self.example.srna_gffs, args_tar, self.example.gffs, merges, 50, methods) output = [[ 'sRNA_0', 'aaa', '6-15', '7-15', '7-15', '+', 'gene0', 'cds0', 'AAA_00001', '100-150', '89-50', '89-50', '+', '-6.5', '1', '-6.5', '1' ], [ 'sRNA_1', 'aaa', '1258-2234', '1259-1267', '1259-1267', '+', 'gene2', 'cds2', 'AAA_00003', '2348-2934', '2337-50', '2337-50', '+', '-10.5', '1', '-10.5', '1' ], [ 'sRNA_2', 'aaa', '3544-6517', '6508-6516', '6508-6516', '-', 'gene0', 'cds0', 'AAA_00001', '100-150', '89-50', '89-50', '+', '-23.5', '1', '-23.5', '1' ]] count = 0 for out in output: for data in overlap: if out == data: count += 1 self.assertEqual(count, 3) count = 0 for out in output: for data in merges: if out == data: count += 1 self.assertEqual(count, 3) def test_merge_last(self): args_tar = self.mock_args.mock() args_tar.top = 2 args_tar.tar_start = 20 args_tar.tar_end = 15 srnas = { "RNAplex": { "srna0": [{ "gene_id": "gene0", "detail": "100-150_+", "target_id": "cds0", "target_locus": "AAA_00001", "energy": -6.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15" }], "srna1": [{ "gene_id": "gene2", "detail": "2348-2934_+", "target_id": "cds2", "target_locus": "AAA_00003", "energy": -10.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15" }], "srna2": [{ "gene_id": "gene0", "detail": "100-150_+", "target_id": "cds0", "target_locus": "AAA_00001", "energy": -23.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15" }, { "gene_id": "gene2", "detail": "2348-2934_+", "target_id": "cds2", "target_locus": "AAA_00003", "energy": -6.5, "rank": 2, "srna_pos": "2,10", "tar_pos": "10,15" }] }, "RNAup": { "srna0": [{ "gene_id": "gene0", "detail": "100-150_+", "target_id": "cds0", "target_locus": "AAA_00001", "energy": -6.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15" }], "srna1": [{ "gene_id": "gene2", "detail": "2348-2934_+", "target_id": "cds2", "target_locus": "AAA_00003", "energy": -10.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15" }], "srna2": [{ "gene_id": "gene0", "detail": "100-150_+", "target_id": "cds0", "target_locus": "AAA_00001", "energy": -23.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15" }] } } merges = [] mrr.merge_last(srnas, self.example.srna_gffs, args_tar, self.example.gffs, merges, 50, "RNAplex", "RNAup", 2, None, False) output = [[ 'sRNA_1', 'aaa', '1258-2234', '1259-1267', '1259-1267', '+', 'gene2', 'cds2', 'AAA_00003', '2348-2934', '2337-50', '2337-50', '+', '-10.5', '1', '-10.5', '1' ], [ 'sRNA_2', 'aaa', '3544-6517', '6508-6516', '6508-6516', '-', 'gene0', 'cds0', 'AAA_00001', '100-150', '89-50', '89-50', '+', '-23.5', '1', '-23.5', '1' ], [ 'sRNA_0', 'aaa', '6-15', '7-15', '7-15', '+', 'gene0', 'cds0', 'AAA_00001', '100-150', '89-50', '89-50', '+', '-6.5', '1', '-6.5', '1' ]] count = 0 for out in output: for data in merges: if out == data: count += 1 self.assertEqual(count, 3)
class TestMergeRNAplexRNAup(unittest.TestCase): def setUp(self): self.test_folder = "test_project" if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) os.mkdir(self.test_folder) self.example = Example() self.mock_args = MockClass() def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_detect_energy(self): srna = {"energy": -2} mrr.detect_energy(self.example.out_rna_txt, srna) self.assertDictEqual(srna, {'energy': -5.3}) srna = {"energy": -8} mrr.detect_energy(self.example.out_rna_txt, srna) self.assertDictEqual(srna, {'energy': -8.0}) def test_print_rank_one(self): out = StringIO() args_tar = self.mock_args.mock() args_tar.top = 2 args_tar.tar_start = 20 args_tar.tar_end = 15 mrr.print_rank_one(self.example.srnas, out, "RNAplex", self.example.gffs, self.example.srna_gffs, args_tar) datas = convert_dict(out.getvalue().split("\n")) refs = convert_dict(self.example.out_print.split("\n")) self.assertDictEqual(datas, refs) def test_read_table(self): rnaplex = os.path.join(self.test_folder, "rnaplex") rnaup = os.path.join(self.test_folder, "rnaup") gen_file(rnaplex, self.example.rnaplex) gen_file(rnaup, self.example.rnaup) srnas = mrr.read_table(self.example.gffs, rnaplex, rnaup) self.assertDictEqual(srnas, {'RNAup': {'srna352': [{'target': 'srna1023', 'energy': 0}, {'tar_pos': '571,576', 'target': 'SAOUHSC_00001|dnaA', 'energy': -4.87, 'srna_pos': '20,25'}, {'tar_pos': '14,30', 'target': 'SAOUHSC_00002', 'energy': -5.91, 'srna_pos': '11,26'}]}, 'RNAplex': {'srna1023': [{'tar_pos': '571,576', 'target': 'SAOUHSC_00001|dnaA', 'energy': -5.3, 'srna_pos': '20,25'}], 'srna352': [{'tar_pos': '163,170', 'target': 'SAOUHSC_00001|dnaA', 'energy': -1.91, 'srna_pos': '24,31'}]}}) def test_get_srna_name(self): output = mrr.get_srna_name(self.example.srna_gffs, "srna0") self.assertEqual(output[0], 'sRNA_0') self.assertEqual(output[1].start, 6) def test_get_target_info(self): output = mrr.get_target_info(self.example.gffs, "AAA_00001") self.assertEqual(output.start, 100) def test_merge_base_rnaplex(self): args_tar = self.mock_args.mock() args_tar.top = 2 args_tar.tar_start = 20 args_tar.tar_end = 15 merges = [] overlap = mrr.merge_base_rnaplex(self.example.srnas, self.example.srna_gffs, args_tar, self.example.gffs, merges) output = [['sRNA_0', 'aaa', '6-15', '7-15', '7-15', '+', 'AAA_00001', '100-150', '89-94', '89-94', '+', '-6.5', '1', '-6.5', '1'], ['sRNA_0', 'aaa', '6-15', '7-12', '7-15', '+', 'AAA_00002|dnaA', '2348-2934', '2330-2342', '2337-2342', '+', '-3.5', '2', '-3.5', '2'], ['sRNA_1', 'aaa', '1258-2234', '1259-1267', '1259-1267', '+', 'AAA_00003', '5544-5597', '5550-5545', '5550-5545', '-', '-10.5', '1', '-10.5', '1'], ['sRNA_2', 'aaa', '3544-6517', '6508-6516', '6508-6516', '-', 'AAA_00001', '100-150', '89-94', '89-94', '+', '-23.5', '1', '-23.5', '1']] count = 0 for out in output: for data in overlap: if out == data: count += 1 self.assertEqual(count, 4) count = 0 for out in output: for data in merges: if out == data: count += 1 self.assertEqual(count, 4) def test_merge_base_rnaup(self): args_tar = self.mock_args.mock() args_tar.top = 2 args_tar.tar_start = 20 args_tar.tar_end = 15 srnas = {"RNAplex": {"srna0": [{"target": "AAA_00001", "energy": -6.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15"}, {"target": "AAA_00002|dnaA", "energy": -3.5, "rank": 2, "srna_pos": "2,10", "tar_pos": "10,15"}], "srna1": [{"target": "AAA_00003", "energy": -10.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15"}], "srna2": [{"target": "AAA_00001", "energy": -23.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15"}, {"target": "AAA_00002|dnaA", "energy": -3.43, "rank": 3, "srna_pos": "2,10", "tar_pos": "10,15"}, {"target": "AAA_00003", "energy": -6.5, "rank": 2, "srna_pos": "2,10", "tar_pos": "10,15"}]}, "RNAup": {"srna0": [{"target": "AAA_00001", "energy": -6.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15"}, {"target": "AAA_00002|dnaA", "energy": -3.5, "rank": 2, "srna_pos": "2,10", "tar_pos": "10,15"}], "srna1": [{"target": "AAA_00003", "energy": -10.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15"}], "srna2": [{"target": "AAA_00001", "energy": -23.5, "rank": 1, "srna_pos": "2,10", "tar_pos": "10,15"}]}} merges = [] mrr.merge_base_rnaup(srnas, self.example.srna_gffs, args_tar, self.example.gffs, merges) output = [['sRNA_1', 'aaa', '1258-2234', '1259-1267', '1259-1267', '+', 'AAA_00003', '5544-5597', '5550-5545', '5550-5545', '-', '-10.5', '1', '-10.5', '1'], ['sRNA_2', 'aaa', '3544-6517', '6508-6516', '6508-6516', '-', 'AAA_00001', '100-150', '89-94', '89-94', '+', '-23.5', '1', '-23.5', '1'], ['sRNA_0', 'aaa', '6-15', '7-15', '7-15', '+', 'AAA_00001', '100-150', '89-94', '89-94', '+', '-6.5', '1', '-6.5', '1'], ['sRNA_0', 'aaa', '6-15', '7-15', '7-15', '+', 'AAA_00002|dnaA', '2348-2934', '2337-2342', '2337-2342', '+', '-3.5', '2', '-3.5', '2']] count = 0 for out in output: for data in merges: if out == data: count += 1 self.assertEqual(count, 4)
class TestRibos(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.test_folder = "test_folder" self.gffs = os.path.join(self.test_folder, "gffs") self.fastas = os.path.join(self.test_folder, "fastas") self.out_folder = os.path.join(self.test_folder, "output") self.database = os.path.join(self.test_folder, "database") self.seq_path = os.path.join(self.test_folder, "seqs") self.tables = os.path.join(self.out_folder, "tables") self.stat = os.path.join(self.out_folder, "statistics") self.scan = os.path.join(self.test_folder, "scan") self.tsss = os.path.join(self.test_folder, "tsss") self.trans = os.path.join(self.test_folder, "trans") self.out_gff = os.path.join(self.out_folder, "gffs") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.tsss) os.mkdir(os.path.join(self.tsss, "tmp")) os.mkdir(self.trans) os.mkdir(os.path.join(self.trans, "tmp")) os.mkdir(self.gffs) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(self.fastas) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(self.out_folder) os.mkdir(self.database) os.mkdir(self.seq_path) os.mkdir(os.path.join(self.out_folder, "tmp_table")) os.mkdir(os.path.join(self.out_folder, "tmp_scan")) os.mkdir(os.path.join(self.out_folder, "tmp_fasta")) os.mkdir(os.path.join(self.out_folder, "scan_Rfam")) os.mkdir(self.tables) os.mkdir(self.scan) os.mkdir(self.stat) os.mkdir(self.out_gff) args = self.mock_args.mock() args.gffs = self.gffs args.fastas = self.fastas args.ribos_out_folder = self.out_folder args.database = self.database args.tsss = self.tsss args.trans = self.trans args.program = 'riboswtich' self.ribo = Ribos(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_scan_extract_rfam(self): self.ribo._run_cmscan = self.mock.mock_run_cmscan rb.modify_table = self.mock.mock_modify_table rb.regenerate_seq = self.mock.mock_regenerate_seq rb.reextract_rbs = self.mock.mock_reextract_rbs prefixs = [] gen_file(os.path.join(self.gffs, "tmp/test.gff"), self.example.gff_file) gen_file(os.path.join(self.fastas, "tmp/test.fa"), self.example.fasta_file) gen_file(os.path.join(self.seq_path, "test.fa"), self.example.fasta_file) gen_file(os.path.join(self.tsss, "tmp/test_TSS.gff"), self.example.tss_file) gen_file(os.path.join(self.trans, "tmp/test_transcript.gff"), self.example.tran_file) gen_file(os.path.join(self.out_folder, "tmp_fasta", "test.fa"), self.example.fasta_file) args = self.mock_args.mock() args.start_codons = ["ATG"] args.fastas = self.fastas args.out_folder = self.out_folder args.gffs = self.gffs args.fuzzy = 5 args.fuzzy_rbs = 2 args.utr = True args.without_rbs = False args.rbs_seq = ["AGGAGG"] args.output_all = "test" args.cutoff = "e_0.01" tmp_files = { "fasta": os.path.join(self.out_folder, "tmp_fasta"), "scan": "tmp_scan", "table": os.path.join(self.out_folder, "tmp_table") } rfam = "Rfam_.cm" suffixs = { "csv": "test.csv", "txt": "test_prescan.txt", "re_txt": "test_scan.txt", "re_csv": "test_scan.csv" } log = open(os.path.join(self.test_folder, "test.log"), "w") self.ribo._scan_extract_rfam(prefixs, args, tmp_files, suffixs, "test", rfam, log) self.assertListEqual(prefixs, ["test"]) self.assertTrue( os.path.exists( os.path.join(self.out_folder, "tmp_fasta", "test_regenerate.fa"))) def test_merge_results(self): rb.stat_and_covert2gff = self.mock.mock_stat_and_covert2gff gen_file(os.path.join(self.gffs, "test.gff"), self.example.gff_file) gen_file( os.path.join(self.out_folder, "tmp_table/test_riboswitch.csv"), self.example.table) gen_file( os.path.join(self.out_folder, "tmp_scan/test_riboswitch_prescan.txt"), self.example.rescan_file) gen_file( os.path.join(self.out_folder, "tmp_scan/test_riboswitch_scan.txt"), self.example.rescan_file) gen_file(os.path.join(self.test_folder, "ids"), self.example.ids) gen_file(os.path.join(self.tables, "test_riboswitch.csv"), self.example.table) gen_file('test_folder/output/tmp_table/test_test_scan.csv', "test") gen_file( os.path.join("test_folder/output", "tmp_fasta", "test_regenerate.fa"), "test") gen_file('test_folder/output/tmp_scan/test_test_prescan.txt', "test") gen_file('test_folder/output/tmp_scan/test_test_scan.txt', "test") if not os.path.exists('test_folder/output/tmp_table/test_test.csv'): gen_file('test_folder/output/tmp_table/test_test.csv', "test") args = self.mock_args.mock() args.start_codons = ["ATG"] args.fastas = self.fastas args.out_folder = self.out_folder args.gffs = self.gffs args.ribos_id = os.path.join(self.test_folder, "ids") args.fuzzy = 3 suffixs = { "csv": "test.csv", "txt": "test_prescan.txt", "re_txt": "test_scan.txt", "re_csv": "test_scan.csv" } tmp_files = { "fasta": os.path.join(self.out_folder, "tmp_fasta"), "scan": os.path.join(self.out_folder, "tmp_scan"), "table": os.path.join(self.out_folder, "tmp_table") } rfam = "Rfam_.cm" log = open(os.path.join(self.test_folder, "test.log"), "w") self.ribo._merge_results(args, os.path.join(self.out_folder, "tmp_scan"), suffixs, tmp_files, os.path.join(self.out_folder, "tmp_scan"), os.path.join(self.out_folder, "scan_Rfam"), os.path.join(self.out_folder, "scan_Rfam"), os.path.join(self.out_folder, "gffs"), "riboswitch", log)
class TestsRNAClass(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_initiate(self): out = StringIO() key = "test" key_list = ["test"] class_name = "test_name" class_num = 0 index = {} content = "testtest" sc.initiate(key, key_list, class_name, class_num, index, out, content) self.assertEqual(out.getvalue(), "1testtest\n") def test_print_stat_title(self): out_stat = StringIO() strain = "aaa" checks = {"limit": False, "first": True, "utr": False, "inter": False} srna_datas = {"aaa": self.example.srnas, "all": self.example.srnas} args = self.mock_args.mock() args.energy = 0 args.nr_hits_num = 0 args.import_info = ["tss", "sec_str", "blast_nr", "blast_srna"] class_num, index = sc.print_stat_title(checks, out_stat, strain, srna_datas, 1, args) self.assertEqual( out_stat.getvalue(), """1 - the normalized(by length of sRNA) free energy change of secondary structure below to 0 2 - sRNA candidates start with TSS (3'UTR derived and interCDS sRNA also includes the sRNA candidates which start with processing site.) 3 - blast can not find the homology from nr database (the cutoff is 0). 4 - blast can not find the homology from sRNA database. 5 - blast can find the homology from sRNA database. All strains: """) self.assertEqual(class_num, 5) self.assertDictEqual( index, { 'sRNA_hit': 5, '2d_energy': 1, 'sRNA_no_hit': 4, 'nr_no_hit': 3, 'with_TSS': 2 }) def test_import_class(self): index = { 'sRNA_hit': 5, '2d_energy': 1, 'sRNA_no_hit': 4, 'nr_no_hit': 3, 'with_TSS': 2 } num_srna = 0 datas_srna = {} datas = {"aaa": self.example.srnas} num = sc.import_class(5, datas_srna, datas, index, num_srna, "aaa", "UTR_derived", "5utr", 0, 0) self.assertEqual(num, 1) self.assertEqual(datas_srna["class_4"][0].start, 230) def test_import_data(self): datas = {"aaa": self.example.srnas, "all": self.example.srnas} index = { 'sRNA_hit': 5, '2d_energy': 1, 'sRNA_no_hit': 4, 'nr_no_hit': 3, 'with_TSS': 2 } num_srna = { "total": 0, "intergenic": 0, "5'UTR_derived": 0, "3'UTR_derived": 0, "interCDS": 0, "in_CDS": 0 } checks = { "limit": False, "first": True, "utr": True, "inter": True, "in_CDS": True, "antisense": False } datas_rna = sc.import_data(5, datas, index, num_srna, "aaa", checks, 0, 0) self.assertEqual(datas_rna["5'UTR_derived"]["class_4"][0].start, 230) self.assertEqual(datas_rna["interCDS"]["class_1"][0].start, 140) self.assertEqual(datas_rna["in_CDS"]["class_1"][0].start, 6166) self.assertEqual(datas_rna["intergenic"]["class_5"][0].start, 5166) def test_print_intersection(self): num_srna = { "total": 3, "intergenic": 1, "5'UTR_derived": 1, "3'UTR_derived": 0, "interCDS": 1 } gff_name = os.path.join(self.test_folder, "test") out_stat = StringIO() keys = ["class_1", "class_4", "class_2", "class_3", "class_5"] datas = { "class_1": self.example.srnas, "class_2": self.example.srnas, "class_3": self.example.srnas, "class_4": self.example.srnas, "class_5": self.example.srnas } sc.print_intersection(datas, keys, 3, gff_name, "total", out_stat) self.assertEqual( out_stat.getvalue(), "\tclass_1 and class_4 and class_2 and class_3 and class_5 = 4(1.3333333333333333)\n" ) results, attributes = extract_info( os.path.join(self.test_folder, "test"), "file") self.assertEqual("\n".join(results), self.example.gff_info) def test_read_file(self): srna_file = os.path.join(self.test_folder, "srna.gff") gen_file(srna_file, self.example.gff_file) srna_datas, strains, checks = sc.read_file(srna_file) self.assertEqual(srna_datas["aaa"][0].start, 140) self.assertEqual(srna_datas["aaa"][1].start, 230) self.assertEqual(srna_datas["bbb"][0].start, 5166) self.assertListEqual(strains, ['all', 'aaa', 'bbb']) self.assertDictEqual( checks, { 'inter': True, 'limit': False, 'utr': True, 'antisense': False, 'in_CDS': True, 'first': True }) def test_sort_keys(self): keys = ["class_3", "class_1", "class_5"] final_keys = sc.sort_keys(keys) self.assertListEqual(final_keys, ['class_1', 'class_3', 'class_5']) def test_classify_srna(self): out_stat_file = os.path.join(self.test_folder, "stat") srna_file = os.path.join(self.test_folder, "srna.gff") gen_file(srna_file, self.example.gff_file) args = self.mock_args.mock() args.energy = 0 args.nr_hits_num = 0 args.in_cds = True args.import_info = ["tss", "sec_str"] sc.classify_srna(srna_file, self.test_folder, out_stat_file, args)
def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder)
class TestDetectUTR(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_import_utr(self): args = self.mock_args.mock() utr_all = {"pri": [], "all": [], "sec": []} utr_strain = { "pri": { "aaa": [] }, "all": { "aaa": [] }, "sec": { "aaa": [] } } args.source = True args.base_5utr = "both" args.fuzzy_5utr = 5 detect = du.import_utr(self.example.tss_fit, utr_strain, utr_all, 140, 340, self.example.tas, 200, args) self.assertTrue(detect[0]) self.assertDictEqual(utr_strain, { 'pri': { 'aaa': [200] }, 'all': { 'aaa': [200] }, 'sec': { 'aaa': [] } }) self.assertDictEqual(utr_all, {'pri': [200], 'all': [200], 'sec': []}) detect = du.import_utr(self.example.tss_nofit, utr_strain, utr_all, 1140, 1190, self.example.tas, 50, args) self.assertFalse(detect[0]) self.assertDictEqual(utr_strain, { 'pri': { 'aaa': [200] }, 'all': { 'aaa': [200] }, 'sec': { 'aaa': [] } }) self.assertDictEqual(utr_all, {'pri': [200], 'all': [200], 'sec': []}) def test_detect_cds(self): nears = [] names = [] checks = [] for gene in self.example.genes: near_cds, cds_name, check_utr = du.detect_cds( self.example.cdss, gene) nears.append(near_cds.start) names.append(cds_name) checks.append(check_utr) self.assertEqual(set(nears), set([148, 220, 5400])) self.assertEqual(set(names), set(['YP_000001', 'AAA_00002', 'CDS:5400-5800_r'])) self.assertEqual(set(checks), set([True, True, True])) def test_check_associated_TSSpredator(self): check_utr, cds_name, near_cds = du.check_associated_TSSpredator( self.example.genes, self.example.tss_fit, self.example.cdss, False, "NA", "AAA_00001") self.assertTrue(check_utr) self.assertEqual(cds_name, "YP_000001") self.assertEqual(near_cds.start, 148) check_utr, cds_name, near_cds = du.check_associated_TSSpredator( self.example.genes, self.example.tss_nofit, self.example.cdss, False, "NA", "AAA_01001") self.assertFalse(check_utr) self.assertEqual(cds_name, "NA") self.assertEqual(near_cds, None) def test_get_5utr_from_TSSpredator(self): utr_datas = du.get_5utr_from_TSSpredator(self.example.tss_fit, self.example.genes, self.example.cdss) self.assertTrue(utr_datas["check"]) self.assertEqual(utr_datas["cds_name"], 'YP_000001') self.assertEqual(utr_datas["locus"], 'AAA_00001') self.assertEqual(utr_datas["near_cds"].start, 148) utr_datas = du.get_5utr_from_TSSpredator(self.example.tss_nofit, self.example.genes, self.example.cdss) self.assertFalse(utr_datas["check"]) self.assertEqual(utr_datas["cds_name"], None) self.assertEqual(utr_datas["locus"], None) self.assertEqual(utr_datas["near_cds"], None) def test_get_5utr_from_other(self): utr_datas = du.get_5utr_from_other(self.example.tss_fit, self.example.genes, self.example.cdss, 300) self.assertTrue(utr_datas["check"]) self.assertEqual(utr_datas["cds_name"], 'YP_000001') self.assertEqual(utr_datas["locus"], 'AAA_00001') self.assertEqual(utr_datas["near_cds"].start, 148) utr_datas = du.get_5utr_from_other(self.example.tss_nofit, self.example.genes, self.example.cdss, 300) self.assertFalse(utr_datas["check"]) self.assertEqual(utr_datas["cds_name"], None) self.assertEqual(utr_datas["locus"], None) self.assertEqual(utr_datas["near_cds"], None) def test_compare_ta(self): args = self.mock_args.mock() args.length = 300 out = StringIO() utr_all = {"pri": [], "all": [], "sec": []} utr_strain = { "pri": { "aaa": [] }, "all": { "aaa": [] }, "sec": { "aaa": [] } } utr_tss = [] num_utr = 0 du.compare_ta(self.example.tas, self.example.genes, self.example.cdss, utr_strain, utr_all, out, args, utr_tss, num_utr) self.assertEqual(set(out.getvalue().split("\n")[:-1]), set([self.example.out_5utr])) out.close() def test_detect_5utr(self): args = self.mock_args.mock() du.read_file = Mock_func().mock_read_file du.plot = Mock_func().mock_plot out_file = os.path.join(self.test_folder, "5utr.gff") args.source = True args.base_5utr = "both" args.length = 300 du.detect_5utr("test.tss", "test.gff", "test.ta", out_file, args) header = ["##gff-version 3"] args.source = False args.base_5utr = "both" du.detect_5utr("test.tss", "test.gff", "test.ta", out_file, args) datas = import_data(out_file) ref = header + [self.example.out_5utr_other] self.assertEqual(datas[1], ref[1]) args.base_5utr = "transcript" du.detect_5utr("test.tss", "test.gff", "test.ta", out_file, args) self.assertEqual(set(datas), set(ref)) args.source = True args.base_5utr = "both" du.detect_5utr("test.tss", "test.gff", "test.ta", out_file, args) datas = import_data(out_file) ref = header + [self.example.out_5utr_tsspredator] self.assertListEqual(datas, ref) def test_compare_term(self): ta_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "TSS", "start": 138, "end": 540, "phase": ".", "strand": "+", "score": "." } attributes_ta = {"ID": "tran0", "Name": "Transcript_0"} ta = Create_generator(ta_dict, attributes_ta, "gff") term = du.compare_term(ta, self.example.terms, 5) self.assertEqual(term.start, 530) def test_get_3utr(self): ta_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "TSS", "start": 138, "end": 540, "phase": ".", "strand": "+", "score": "." } attributes_ta = {"ID": "tran0", "Name": "Transcript_0"} ta = Create_generator(ta_dict, attributes_ta, "gff") cds_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "CDS", "start": 150, "end": 500, "phase": ".", "strand": "+", "score": "." } attributes_cds = {"ID": "cds0", "Name": "CDS_0"} cds = Create_generator(cds_dict, attributes_cds, "gff") attributes = ["ID=3utr0"] out = StringIO() utr_all = [] utr_strain = {"aaa": []} args = self.mock_args.mock() args.length = 300 args.base_3utr = "transcript" args.fuzzy_3utr = 10 utr_ta = [] du.get_3utr(ta, cds, utr_all, utr_strain, attributes, 0, out, args, utr_ta) self.assertEqual(set(out.getvalue().split("\n")[:-1]), set(self.example.out_3utr.split("\n"))) out.close() def test_get_near_cds(self): ta_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "TSS", "start": 138, "end": 540, "phase": ".", "strand": "+", "score": "." } attributes_ta = {"ID": "tran0", "Name": "Transcript_0"} ta = Create_generator(ta_dict, attributes_ta, "gff") attributes = ["ID=3utr0"] near_cds = du.get_near_cds(self.example.cdss, self.example.genes, ta, attributes, 300) self.assertEqual(near_cds.start, 148) def test_detect_3utr(self): args = self.mock_args.mock() args.fuzzy = 5 args.base_3utr = "transcript" args.fuzzy_3utr = 10 args.length = 300 du.read_file = Mock_func().mock_read_file du.plot = Mock_func().mock_plot out_file = os.path.join(self.test_folder, "3utr.gff") du.detect_3utr("test.ta", "test.gff", "test.term", out_file, args) datas = import_data(out_file) self.assertEqual(set(datas), set(self.example.out_3utr_gff.split("\n")))
class TestCircRNA(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_get_feature(self): attributes_cds = {"ID": "cds0", "Name": "CDS_0", "locus_tag": "AAA_00001", "protein_id": "YP_918384.3"} attributes = circ.get_feature(Create_generator(self.example.cds_dict, attributes_cds, "gff")) self.assertEqual(attributes, "AAA_00001") attributes_cds = {"ID": "cds0", "Name": "CDS_0", "protein_id": "YP_918384.3"} attributes = circ.get_feature(Create_generator(self.example.cds_dict, attributes_cds, "gff")) self.assertEqual(attributes, "YP_918384.3") attributes_cds = {"ID": "cds0", "Name": "CDS_0"} attributes = circ.get_feature(Create_generator(self.example.cds_dict, attributes_cds, "gff")) self.assertEqual(attributes, "cds0:122-267_f") def test_detect_conflict(self): circ_dict = {"seq_id": "aaa", "source": "Refseq", "feature": "circRNA", "start": 100, "end": 467, "phase": ".", "strand": "+", "score": ".", "support": 30, "start_site": 30, "end_site": 35, "situation": "P", "splice_type": "C"} attributes_circ = {"ID": "circrna0", "Name": "circRNA_0"} circrna = Create_generator(circ_dict, attributes_circ, "circ") gffs = [Create_generator(self.example.cds_dict, self.example.attributes_cds, "gff")] args = self.mock_args.mock() args.start_ratio = 0.3 args.end_ratio = 0.3 args.support = 5 out = StringIO() out_best = StringIO() circ.detect_conflict(gffs, circrna, 0, out, out_best, args) self.assertEqual(out.getvalue(), "circRNA_0\taaa\t+\t100\t467\tAAA_00001\t30\t1.0\t0.8571428571428571\n") out.close() def test_get_circrna(self): circs = [] gffs = [] for index in range(0, 5): circs.append(Create_generator(self.example.circ_dict[index], self.example.attributes_circ[index], "circ")) for index in range(0, 3): gffs.append(Create_generator(self.example.gffs_dict[index], self.example.attributes_gffs[index], "gff")) out = StringIO() out_best = StringIO() args = self.mock_args.mock() args.start_ratio = 0.3 args.end_ratio = 0.3 args.support = 5 nums = circ.get_circrna(circs, gffs, 50, out, out_best, args) self.assertDictEqual(nums["support"], {'aaa': {0: 2, 20: 1, 5: 2, 25: 1, 10: 2, 30: 1, 15: 1}, 'all': {0: 3, 20: 1, 5: 3, 25: 1, 10: 2, 30: 1, 15: 1}, 'bbb': {0: 1, 5: 1}}) self.assertDictEqual(nums["circular"], {'bbb': 1, 'aaa': 2, 'all': 3}) self.assertDictEqual(nums["conflict"], {'bbb': {0: 1, 5: 1}, 'aaa': {}, 'all': {0: 1, 5: 1}}) def test_detect_circrna(self): out_file = os.path.join(self.test_folder, "out_all.csv") stat_file = os.path.join(self.test_folder, "stat.csv") circ.read_file = Mock_read_file().read_file args = self.mock_args.mock() args.start_ratio = 0.5 args.end_ratio = 0.5 args.support = 5 args.hypo = True circ.detect_circrna("test.circ", "test.gff", out_file, args, stat_file) circs = import_data(out_file) stats = import_data(stat_file) self.assertEqual(set(circs), set(self.example.out_file.split("\n"))) self.assertEqual(set(stats), set(self.example.stat_file.split("\n")))
class TestsRNADetection(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.example = Example() self.mock = Mock_func() self.test_folder = "test_folder" self.gffs = "test_folder/gffs" self.tsss = "test_folder/tsss" self.sorf = "test_folder/sORF" self.out = "test_folder/output" self.trans = "test_folder/trans" self.fastas = "test_folder/fastas" self.tex = "test_folder/tex" self.frag = "test_folder/frag" self.pros = "test_folder/pros" self.terms = "test_folder/terms" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.gffs) os.mkdir(self.tsss) os.mkdir(os.path.join(self.tsss, "tmp")) os.mkdir(self.out) os.mkdir(self.trans) os.mkdir(os.path.join(self.trans, "tmp")) os.mkdir(self.fastas) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(self.tex) os.mkdir(self.frag) os.mkdir(self.pros) os.mkdir(os.path.join(self.pros, "tmp")) os.mkdir(self.sorf) os.mkdir(os.path.join(self.sorf, "tmp")) os.mkdir(self.terms) args = self.mock_args.mock() args.tss_folder = self.tsss args.pro_folder = self.pros args.out_folder = self.out args.sorf_file = self.sorf args.fastas = self.fastas args.trans = self.trans args.terms = self.terms self.srna = sRNADetection(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) os.chdir(current_path) if os.path.exists("tmp"): shutil.rmtree("tmp") if os.path.exists("tmp_srna.csv"): os.remove("tmp_srna.csv") if os.path.exists("tmp_srna.gff"): os.remove("tmp_srna.gff") if os.path.exists("tmp_blast.txt"): os.remove("tmp_blast.txt") def test_check_folder_exist(self): path_ = self.srna._check_folder_exist(self.sorf) self.assertEqual(path_, "test_folder/sORF/tmp") def test_formatdb(self): database = "test_folder/test.fa" gen_file(database, "test") sr.change_format = self.mock.mock_change_format self.srna._run_format = self.mock.mock_run_format self.srna._formatdb(database, "type_", self.out, "blast_path", "sRNA") self.assertTrue(os.path.exists(os.path.join(self.out, "log.txt"))) def test_check_necessary_file(self): self.srna.multiparser = Mock_multiparser self.srna._check_gff = self.mock.mock_check_gff args = self.mock_args.mock() args.trans = self.trans args.tsss = self.tsss args.pros = self.pros args.import_info = ["tss", "blast_nr", "blast_srna", "sec_str", "sorf"] args.fastas = self.fastas args.terms = self.terms args.sorf_file = self.sorf args.gffs = self.gffs args.tex_wigs = self.tex args.frag_wigs = self.frag args.utr_srna = True self.srna._check_necessary_file(args) def test_run_program(self): self.srna.multiparser = Mock_multiparser self.srna._check_gff = self.mock.mock_check_gff self.srna._run_normal = self.mock.mock_run_normal self.srna._run_utrsrna = self.mock.mock_run_utrsrna self.srna._merge_tex_frag_datas = self.mock.mock_merge_tex_frag_datas sr.filter_frag = self.mock.mock_run_filter_frag sr.merge_srna_gff = self.mock.mock_merge_srna_gff sr.merge_srna_table = self.mock.mock_merge_srna_table gen_file(os.path.join(self.gffs, "test.gff"), self.example.sorf_file) gen_file(os.path.join(self.trans, "test_transcript.gff"), self.example.sorf_file) gen_file(os.path.join(self.tsss, "test_TSS.gff"), self.example.sorf_file) gen_file(os.path.join(self.tsss, "test_processing.gff"), self.example.sorf_file) fuzzy_tsss = {"inter": 3} args = self.mock_args.mock() args.import_info = ["tss", "blast_nr", "blast_srna", "sec_str", "sorf"] args.trans = self.trans args.tsss = self.tsss args.pros = self.pros args.max_len = 300 args.min_len = 30 args.tex_notex = "tex_notex" args.fuzzy_tsss = fuzzy_tsss args.out_folder = self.out args.table_best = True args.wig_path = "wig_path" args.merge_wigs = "merge" args.libs = "libs" args.gffs = self.gffs args.in_cds = False args.utr_srna = True args.cutoff_overlap = 0.5 prefixs = self.srna._run_program(args) self.assertListEqual(prefixs, ['test']) def test_get_seq_sec(self): sr.extract_energy = self.mock.mock_extract_energy self.srna.helper.get_seq = self.mock.mock_get_seq self.srna._run_RNAfold = self.mock.mock_run_RNAfold os.mkdir(os.path.join(self.out, "tmp_srna")) gen_file(os.path.join(self.fastas, "test.fa"), ">test\nAAATTTGGGCCC") datas = self.srna._get_seq_sec(self.fastas, self.out, "test", self.test_folder, self.test_folder, "vienna_path") self.assertEqual(datas["sec"].split("/")[-1], "test_folder") self.assertEqual(datas["dot"].split("/")[-1], "test_folder") self.assertEqual(datas["main"].split("/")[-1], datas["tmp"].split("/")[-4]) self.assertEqual(datas["tmp"].split("/")[-1], "tmp_srna") def test_replot_sec_to_pdf(self): self.srna._run_replot = self.mock.mock_run_replot self.srna._convert_pdf = self.mock.mock_convert_pdf gen_file(os.path.join(self.tsss, "test.rss.pdf"), "test") gen_file(os.path.join(self.tsss, "test.dp.pdf"), "test") tmp_paths = {"dot": self.out, "sec": self.fastas, "tmp": self.tsss} self.srna._replot_sec_to_pdf("vienna_util", tmp_paths, "ps2pdf14_path", "test") self.assertTrue( os.path.exists(os.path.join(tmp_paths["dot"], "test/test.dp.pdf"))) self.assertTrue( os.path.exists(os.path.join(tmp_paths["sec"], "test/test.rss.pdf"))) def test_plot_mountain(self): self.srna._run_mountain = self.mock.mock_run_mountain tmp_paths = {"main": self.test_folder, "tmp": self.tsss} moun_path = "fastas" gen_file(os.path.join(tmp_paths["tmp"], "test.dp.ps"), "test") self.srna._plot_mountain(True, moun_path, tmp_paths, "test", "vienna_util") self.assertTrue("test_folder/fastas/test/test.mountain.pdf") def test_compute_2d_and_energy(self): sr.extract_energy = self.mock.mock_extract_energy sr.change_format = self.mock.mock_change_format self.srna._run_replot = self.mock.mock_run_replot self.srna._convert_pdf = self.mock.mock_convert_pdf self.srna._run_mountain = self.mock.mock_run_mountain os.mkdir(os.path.join(self.out, "mountain_plot")) sec_path = os.path.join(self.out, "sec_structure") os.mkdir(sec_path) os.mkdir(os.path.join(sec_path, "sec_plot")) os.mkdir(os.path.join(sec_path, "dot_plot")) tmp_paths = { "dot": self.out, "sec": self.fastas, "tmp": self.tsss, "main": self.test_folder } gen_file(os.path.join(self.fastas, "tmp/test.fa"), ">test\nAAATTTGGGCCC") gen_file(os.path.join(self.out, "tmp_basic_test"), self.example.srna_file) gen_file(os.path.join(self.out, "tmp_energy_test"), "test") args = self.mock_args.mock() args.out_folder = self.out args.fastas = self.fastas args.vienna_path = "test" args.vienna_util = "test" args.mountain = True args.ps2pdf14_path = "test" self.srna._compute_2d_and_energy(args, ["test"]) datas = import_data(os.path.join(self.out, "tmp_basic_test")) self.assertEqual("\n".join(datas), "test") def test_blast(self): sr.extract_blast = self.mock.mock_extract_blast self.srna._run_blast = self.mock.mock_run_blast self.srna._run_format = self.mock.mock_run_format gen_file(os.path.join(self.out, "tmp_basic_test"), self.example.srna_file) gen_file(os.path.join(self.out, "tmp_nr_test"), "test") gen_file(os.path.join(self.fastas, "tmp/test.fa"), ">test\nAAATTTGGGCCC") args = self.mock_args.mock() args.blast_path = "test" args.fastas = self.fastas args.out_folder = self.out self.srna._blast("database", False, "dna", args, ["test"], "blast_all", "nr", 0.0001) datas = import_data(os.path.join(self.out, "tmp_basic_test")) self.assertEqual("\n".join(datas), "test") def test_class_srna(self): sr.classify_srna = self.mock.mock_classify_srna sr.gen_srna_table = self.mock.mock_gen_srna_table gff_out = os.path.join(self.out, "gffs") table_out = os.path.join(self.out, "tables") stat_out = os.path.join(self.out, "stat") os.mkdir(gff_out) os.mkdir(table_out) os.mkdir(stat_out) os.mkdir(os.path.join(table_out, "for_class")) os.mkdir(os.path.join(gff_out, "for_class")) args = self.mock_args.mock() args.max_len = 300 args.min_len = 30 args.import_info = ["tss", "blast_nr", "blast_srna", "sec_str", "sorf"] self.srna._class_srna(["test"], args) self.assertTrue(os.path.exists(os.path.join(gff_out, "for_class/test"))) self.assertTrue( os.path.exists(os.path.join(table_out, "for_class/test"))) def test_filter_srna(self): sr.classify_srna = self.mock.mock_classify_srna sr.gen_srna_table = self.mock.mock_gen_srna_table sr.extract_blast = self.mock.mock_extract_blast self.srna._run_blast = self.mock.mock_run_blast self.srna._run_format = self.mock.mock_run_format sr.extract_energy = self.mock.mock_extract_energy sr.change_format = self.mock.mock_change_format self.srna._run_replot = self.mock.mock_run_replot self.srna._convert_pdf = self.mock.mock_convert_pdf self.srna._run_mountain = self.mock.mock_run_mountain self.srna.multiparser = Mock_multiparser self.srna._check_gff = self.mock.mock_check_gff self.srna._run_normal = self.mock.mock_run_normal self.srna._run_utrsrna = self.mock.mock_run_utrsrna sr.merge_srna_gff = self.mock.mock_merge_srna_gff sr.merge_srna_table = self.mock.mock_merge_srna_table sr.extract_energy = self.mock.mock_extract_energy self.srna.helper.get_seq = self.mock.mock_get_seq self.srna._run_RNAfold = self.mock.mock_run_RNAfold stat_out = os.path.join(self.out, "stat") if "mountain_plot" not in os.listdir(self.out): os.mkdir(os.path.join(self.out, "mountain_plot")) sec_path = os.path.join(self.out, "sec_structure") if "sec_structure" not in os.listdir(self.out): os.mkdir(sec_path) os.mkdir(os.path.join(sec_path, "sec_plot")) os.mkdir(os.path.join(sec_path, "dot_plot")) gen_file(os.path.join(self.fastas, "tmp/test.fa"), ">test\nAAATTTGGGCCC") gen_file(os.path.join(self.out, "sRNA_seq_test"), ">test\nAAATTTGGGCCC") gen_file(os.path.join(self.out, "tmp_basic_test"), self.example.srna_file) gen_file(os.path.join(self.out, "tmp_energy_test"), "test") gen_file(os.path.join(self.out, "tmp_nr_test"), "test") gen_file(os.path.join(self.out, "tmp_sRNA_test"), "test") gen_file(os.path.join(self.out, "tmp_sRNA_test.csv"), "test") gen_file(os.path.join(self.test_folder, "srna"), "test") gen_file(os.path.join(self.test_folder, "nr"), "test") sr.blast_class = self.mock.mock_blast_class sr.srna_sorf_comparison = self.mock.mock_srna_sorf_comparison args = self.mock_args.mock() args.import_info = ["tss", "blast_nr", "blast_srna", "sec_str", "sorf"] args.out_folder = self.out args.fastas = self.fastas args.vienna_path = "test" args.vienna_util = "test" args.table_best = True args.in_cds = False args.ps2pdf14_path = "test" args.sorf_file = self.sorf args.mountain = True args.nr_database = os.path.join(self.test_folder, "nr") args.srna_database = os.path.join(self.test_folder, "srna") args.blast_path = "blast_path" args.nr_format = False args.srna_format = False args.e_nr = 0 args.e_srna = 0 self.srna._filter_srna(args, ["test"]) datas = import_data(os.path.join(self.out, "tmp_basic_test")) self.assertEqual("\n".join(datas), "test")
class TestSNPCalling(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" self.fasta = os.path.join(self.test_folder, "fasta") self.snp_folder = os.path.join(self.test_folder, "snp") self.table = os.path.join(self.test_folder, "table") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.fasta) os.mkdir(self.snp_folder) os.mkdir(self.table) os.mkdir(os.path.join(self.test_folder, "compare_reference")) os.mkdir(os.path.join(self.test_folder, "compare_reference/seqs")) os.mkdir( os.path.join(self.test_folder, "compare_reference/seqs/with_BAQ")) os.mkdir( os.path.join(self.test_folder, "compare_reference/statistics")) args = self.mock_args.mock() args.types = "reference" args.out_folder = self.test_folder args.fastas = self.fasta self.snp = SNPCalling(args) self.mock = Mock_func() def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_transcript_snp(self): fasta = os.path.join(self.test_folder, "NC_007795.1.fa") gen_file(fasta, self.example.fasta) snp = os.path.join(self.test_folder, "NC_007795.1.csv") gen_file(snp, self.example.snp) args = self.mock_args.mock() args.depth = 5 args.fraction = 0.3 args.quality = 2 args.depth_s = "n_10" args.depth_b = "a_2" args.dp4_sum = "n_10" args.dp4_frac = 0.5 args.idv = "n_10" args.imf = 0.5 args.filters = ["VDB_s0.1"] args.min_sample = 2 os.mkdir( os.path.join(self.test_folder, "compare_reference/seqs/with_BAQ/test")) depth_file = os.path.join(self.test_folder, "tmp_depth") gen_file(depth_file, self.example.depth_file) self.snp._transcript_snp(fasta, snp, "test", "with", "test", 10, self.table, args) datas = import_data( os.path.join( self.test_folder, "compare_reference/statistics/stat_test_with_BAQ_SNP_best.csv") ) self.assertEqual("\n".join(datas), self.example.out_stat) datas = import_data( os.path.join( self.test_folder, "compare_reference/seqs/with_BAQ/test/test_NC_007795.1_1_1.fa") ) self.assertEqual("\n".join(datas), ">NC_007795.1\nAaTTGaaTCCCGAACGACAGTTAT") os.remove("test_seq_reference.csv") os.remove("test_best.vcf") os.remove("test_NC_007795.1_SNP_QUAL_best.png") os.remove("test_NC_007795.1_SNP_QUAL_raw.png") def test_run_sub(self): self.snp._run_tools = self.mock.mock_run_tools self.snp._transcript_snp = self.mock.mock_transcript_snp file_prefixs = {"raw_prefix": "test", "table_prefix": "test"} args = self.mock_args.mock() self.snp._run_sub(args, "fasta", "with", file_prefixs, "test", self.test_folder, 10) self.assertTrue( os.path.exists( os.path.join(self.test_folder, "compare_reference/seqs/with_BAQ/test"))) def test_run_program(self): self.snp._run_sub = self.mock.mock_run_sub args = self.mock_args.mock() args.program = ["with_BAQ"] self.snp._run_program("fasta", "test", "test", 10, "table", args) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test"))) def test_detect_fasta(self): datas = self.snp._detect_fasta("test.fa") self.assertEqual(datas, (True, 'test')) def test_merge_bams(self): args = self.mock_args.mock() args.frag_bams = os.path.join(self.test_folder, "frag_bams") args.normal_bams = os.path.join(self.test_folder, "tex_bams") os.mkdir(args.normal_bams) os.mkdir(args.frag_bams) self.snp._run_bam = self.mock.mock_run_bam gen_file(os.path.join(args.normal_bams, "tex.bam"), "test") gen_file(os.path.join(args.normal_bams, "notex.bam"), "test") gen_file(os.path.join(args.frag_bams, "farg.bam"), "test") args.bams = [args.frag_bams, args.normal_bams] args.samtools_path = "test" num = self.snp._merge_bams(args) self.assertEqual(num, 2) def test_modify_header(self): gen_file(os.path.join(self.fasta, "test.fa"), ">AAA|BBB|CCC|DDD|EEE\nAATTAATTGGCC") self.snp._modify_header(self.fasta) datas = import_data(os.path.join(self.fasta, "test.fa")) self.assertEqual("\n".join(datas), ">DDD\nAATTAATTGGCC") def test_get_genome_name(self): self.snp._get_header = self.mock.mock_get_header gen_file(os.path.join(self.test_folder, "header"), self.example.bam) args = self.mock_args.mock() args.samtools_path = "test" seq_names = self.snp._get_genome_name(args) def test_run_snp_calling(self): self.snp._get_header = self.mock.mock_get_header self.snp._run_bam = self.mock.mock_run_bam self.snp._run_sub = self.mock.mock_run_sub self.snp._run_tools = self.mock.mock_run_tools self.snp._transcript_snp = self.mock.mock_transcript_snp gen_file(os.path.join(self.fasta, "test.fa"), ">AAA|BBB|CCC|DDD|EEE\nAATTAATTGGCC") gen_file(os.path.join(self.test_folder, "header"), self.example.bam) gen_file(os.path.join(self.test_folder, "whole_reads.bam"), "test") gen_file(os.path.join(self.test_folder, "whole_reads_sorted.bam"), "test") args = self.mock_args.mock() args.types = "reference" args.program = ["with_BAQ"] args.bams = [ os.path.join(self.test_folder, "frag_bams"), os.path.join(self.test_folder, "tex_bams") ] args.frag_bams = os.path.join(self.test_folder, "frag_bams") args.normal_bams = os.path.join(self.test_folder, "tex_bams") os.mkdir(args.normal_bams) os.mkdir(args.frag_bams) gen_file(os.path.join(args.normal_bams, "tex.bam"), "test") gen_file(os.path.join(args.normal_bams, "notex.bam"), "test") gen_file(os.path.join(args.frag_bams, "farg.bam"), "test") args.samtools_path = "test" self.snp.run_snp_calling(args)
class TestTerminator(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.mock_parser = Mock_Multiparser() self.test_folder = "test_folder" self.out = "test_folder/output" self.fastas = "test_folder/fastas" self.gffs = "test_folder/gffs" self.srnas = "test_folder/srnas" self.trans = "test_folder/trans" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.out) os.mkdir(self.fastas) os.mkdir(self.gffs) os.mkdir(self.srnas) os.mkdir(self.trans) os.mkdir(os.path.join(self.out, "tables")) os.mkdir(os.path.join(self.out, "gffs")) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(os.path.join(self.fastas, "tmp")) args = self.mock_args.mock() args.gffs = self.gffs args.fastas = self.fastas args.trans = self.trans args.out_folder = self.out args.srnas = self.srnas self.term = Terminator(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) if os.path.exists("tmp_transterm"): shutil.rmtree("tmp_transterm") if os.path.exists("tmp_term_table"): shutil.rmtree("tmp_term_table") if os.path.exists("tmp_merge_gff"): shutil.rmtree("tmp_merge_gff") def test_convert_gff2rntptt(self): os.mkdir(os.path.join(self.srnas, "tmp")) gen_file(os.path.join(self.gffs, "aaa.gff"), self.example.gff_file) gen_file(os.path.join(self.srnas, "aaa_sRNA.gff"), self.example.srna_file) gen_file(os.path.join(self.fastas, "aaa.fa"), self.example.fasta_file) file_types, prefixs = self.term._convert_gff2rntptt( self.gffs, self.fastas, self.srnas) self.assertDictEqual(file_types, {'aaa': 'srna'}) self.assertListEqual(prefixs, ['aaa']) def test_combine_annotation(self): test1 = os.path.join(self.test_folder, "test1.ptt") test2 = os.path.join(self.test_folder, "test2.ptt") gen_file(test1, self.example.ptt) gen_file(test2, self.example.ptt) files = [test1, test2] combine_file = os.path.join(self.test_folder, "combine") self.term._combine_annotation(combine_file, files) datas = import_data(combine_file) result = self.example.ptt.split("\n")[3:] self.assertEqual("\n".join(datas), "\n".join(result + result)) def test_run_TransTermHP(self): self.term._TransTermHP = self.mock.mock_TransTermHP os.mkdir(os.path.join(self.gffs, "tmp/combine")) gen_file(os.path.join(self.gffs, "tmp/combine/aaa.ptt"), self.example.ptt) gen_file(os.path.join(self.fastas, "tmp/aaa.fa"), self.example.fasta_file) args = self.mock_args.mock() args.gffs = self.gffs args.fastas = self.fastas args.hp_folder = self.out self.term._run_TransTermHP(args) self.assertTrue(os.path.exists(os.path.join(self.out, "aaa"))) def test_convert_to_gff(self): self.term.multiparser = self.mock_parser hp_folder = os.path.join(self.out, "aaa") os.mkdir(hp_folder) gen_file(os.path.join(hp_folder, "aaa_best_terminator_after_gene.bag"), self.example.bag) os.mkdir("tmp_transterm") args = self.mock_args.mock() args.hp_folder = self.out args.gffs = self.gffs self.term._convert_to_gff(["aaa"], args) datas = import_data(os.getcwd() + "/tmp_transterm/aaa_transtermhp.gff") self.assertEqual("\n".join(datas), self.example.gff_bag) def test_merge_sRNA(self): os.mkdir(os.path.join(self.srnas, "tmp")) self.term.multiparser = self.mock_parser gen_file(os.path.join(self.gffs, "aaa.gff"), self.example.gff_file) gen_file(os.path.join(self.srnas, "tmp/aaa_sRNA.gff"), self.example.srna_file) merge = self.term._merge_sRNA(self.srnas, ["aaa"], self.gffs) self.assertEqual(merge.split("/")[-1], "tmp_merge_gff") shutil.rmtree("tmp_merge_gff") def test_move_file(self): term_outfolder = self.gffs csv_outfolder = self.out gen_file(os.path.join(term_outfolder, "aaa_term.gff"), self.example.term_file) if (not os.path.exists("tmp_term_table")): os.mkdir("tmp_term_table") gen_file("tmp_term_table/aaa_term_raw.csv", "test") self.term._move_file(term_outfolder, csv_outfolder) shutil.rmtree("tmp_term_table") self.assertTrue( "test_folder/output/gffs/all_candidates/aaa_term_all.gff") self.assertTrue( "test_folder/output/tables/all_candidates/aaa_term_all.csv") def test_compute_intersection_forward_reverse(self): self.term.multiparser = self.mock_parser te.intergenic_seq = self.mock.mock_intergenic_seq te.poly_t = self.mock.mock_poly_t te.detect_coverage = self.mock.mock_detect_coverage self.term._run_rnafold = self.mock.mock_run_rnafold term_outfolder = os.path.join(self.out, "gffs") csv_outfolder = os.path.join(self.out, "tables") args = self.mock_args.mock() args.trans = self.trans args.fastas = self.fastas args.tex_notex = "tex_notex" args.libs = "libs" args.replicates = "rep" args.RNAfold_path = "test" self.term._compute_intersection_forward_reverse(["aaa"], self.test_folder, "wig_path", "merge_wigs", args) self.assertTrue(os.path.join(self.out, "inter_seq_aaa")) self.assertTrue(os.path.join(self.out, "inter_sec_aaa")) def test_compute_stat(self): term_outfolder = os.path.join(self.out, "gffs") csv_outfolder = os.path.join(self.out, "tables") te.stat_term = self.mock.mock_stat_term gen_file( os.path.join(term_outfolder, "all_candidates/aaa_term_all.gff"), self.example.term_file) gen_file(os.path.join(term_outfolder, "best_candidates/aaa_term.csv"), self.example.term_file) gen_file( os.path.join(term_outfolder, "expressed_candidates/aaa_term.csv"), self.example.term_file) gen_file( os.path.join(term_outfolder, "non_expressed_candidates/aaa_term.csv"), self.example.term_file) args = self.mock_args.mock() args.stat = True args.out_folder = self.out self.term._compute_stat(args) self.assertTrue( os.path.exists( os.path.join(csv_outfolder, "expressed_candidates/aaa_term.csv"))) self.assertTrue( os.path.exists( os.path.join(csv_outfolder, "best_candidates/aaa_term.csv"))) self.assertTrue( os.path.exists( os.path.join(csv_outfolder, "non_expressed_candidates/aaa_term.csv"))) def test_run_terminator(self): te.stat_term = self.mock.mock_stat_term te.intergenic_seq = self.mock.mock_intergenic_seq te.poly_t = self.mock.mock_poly_t te.detect_coverage = self.mock.mock_detect_coverage self.term.multiparser = self.mock_parser self.term._run_rnafold = self.mock.mock_run_rnafold self.term._TransTermHP = self.mock.mock_TransTermHP self.term._compare_term_tran = self.mock.mock_compare_term_tran self.term._remove_tmp_file = self.mock.mock_remove_tmp_file os.mkdir(os.path.join(self.srnas, "tmp")) os.mkdir(os.path.join(self.trans, "tmp")) gen_file(os.path.join(self.gffs, "tmp/aaa.gff"), self.example.gff_file) gen_file(os.path.join(self.fastas, "tmp/aaa.fa"), self.example.fasta_file) gen_file(os.path.join(self.srnas, "tmp/aaa_sRNA.gff"), self.example.srna_file) gen_file(os.path.join(self.trans, "tmp/aaa_transcript.gff"), self.example.tran_file) tex_wigs = os.path.join(self.test_folder, "tex") frag_wigs = os.path.join(self.test_folder, "frag") os.mkdir(tex_wigs) os.mkdir(frag_wigs) gen_file(os.path.join(frag_wigs, "frag.wig"), "text") gen_file(os.path.join(tex_wigs, "tex.wig"), "text") args = self.mock_args.mock() args.out_folder = self.out args.fastas = self.fastas args.gffs = self.gffs args.trans = self.trans args.srnas = self.srnas args.tex_wigs = tex_wigs args.frag_wigs = frag_wigs args.hp_folder = self.test_folder args.tex_notex = "tex_notex" args.wig_path = self.test_folder args.merge_wigs = self.test_folder args.RNAfold_path = "RNAfold_path" args.stat = True args.fuzzy_up_ta = 2 args.fuzzy_up_gene = 2 args.fuzzy_down_ta = 2 args.fuzzy_down_gene = 2 self.term.run_terminator(args) self.assertTrue( os.path.exists(os.path.join(self.out, "tables/all_candidates"))) self.assertTrue( os.path.exists( os.path.join(self.out, "tables/expressed_candidates"))) self.assertTrue( os.path.exists(os.path.join(self.out, "tables/best_candidates"))) self.assertTrue( os.path.exists(os.path.join(self.out, "gffs/all_candidates"))) self.assertTrue( os.path.exists(os.path.join(self.out, "gffs/expressed_candidates"))) self.assertTrue( os.path.exists(os.path.join(self.out, "gffs/best_candidates")))
class TestsTSSpredator(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.mock = Mock_func() self.mock_parser = Mock_Multiparser() self.example = Example() self.test_folder = "test_folder" self.trans = "test_folder/trans" self.out = "test_folder/output" self.wigs = "test_folder/wigs" self.gffs = "test_folder/gffs" self.tsss = "test_folder/tsss" self.fastas = "test_folder/fastas" self.manual = "test_folder/manuals" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.trans) os.mkdir(self.out) os.mkdir(self.wigs) os.mkdir(self.gffs) os.mkdir(self.tsss) os.mkdir(self.fastas) os.mkdir(self.manual) args = self.mock_args.mock() args.out_folder = self.out args.ta_files = self.trans args.gffs = self.gffs args.wig_folder = self.wigs args.fastas = self.fastas args.manual = self.manual self.tss = TSSpredator(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) if os.path.exists("tmp"): shutil.rmtree("tmp") def test_print_lib(self): out = StringIO() lib_list = [{ "condition": 1, "replicate": "a", "wig": "test_1.wig" }, { "condition": 2, "replicate": "a", "wig": "test_2.wig" }] self.tss._print_lib(2, lib_list, out, self.wigs, "test", ["a"]) self.assertEqual(out.getvalue(), ("test_1a = test_folder/wigs/test_1.wig\n" "test_2a = test_folder/wigs/test_2.wig\n")) def test_import_lib(self): out = StringIO() libs = [ "test1_forward.wig:notex:1:a:+", "test1_reverse.wig:notex:1:a:-", "test1_TEX_forward.wig:tex:1:a:+", "test1_TEX_reverse.wig:tex:1:a:-" ] gen_file(os.path.join(self.wigs, "test1_forward.wig_STRAIN_test.wig"), "test") gen_file(os.path.join(self.wigs, "test1_reverse.wig_STRAIN_test.wig"), "test") gen_file( os.path.join(self.wigs, "test1_TEX_forward.wig_STRAIN_test.wig"), "test") gen_file( os.path.join(self.wigs, "test1_TEX_reverse.wig_STRAIN_test.wig"), "test") self.tss._import_lib(libs, self.wigs, "test", out, "test.gff", "TSS", "test.fa") self.assertListEqual(out.getvalue().split("\n"), [ "annotation_1 = test.gff", "fivePrimeMinus_1a = test_folder/wigs/test1_TEX_reverse.wig", "fivePrimePlus_1a = test_folder/wigs/test1_TEX_forward.wig", "genome_1 = test.fa", "" ]) def test_gen_config(self): os.mkdir(os.path.join(self.out, "MasterTables")) os.mkdir(os.path.join(self.wigs, "tmp")) config_file = os.path.join(self.test_folder, "config") libs = [ "test1_forward.wig:notex:1:a:+", "test1_reverse.wig:notex:1:a:-", "test1_TEX_forward.wig:tex:1:a:+", "test1_TEX_reverse.wig:tex:1:a:-" ] args = self.mock_args.mock() args.out_folder = self.out args.program = "TSS" args.height = 0.3 args.height_reduction = 0.2 args.factor = 2.0 args.factor_reduction = 0.5 args.base_height = 0.00 args.enrichment_factor = 2.0 args.processing_factor = 1.5 args.utr_length = 300 args.cluster = 3 args.repmatch = ["all_2"] args.libs = libs args.output_prefixs = ["test1"] args.specify_strains = None self.tss._gen_config("test", args, self.gffs + "/tmp/test.gff", self.wigs + "/tmp", self.fastas + "/tmp/test.fa", config_file) datas = import_data(config_file) self.assertEqual("\n".join(datas), self.example.config) def test_set_gen_config(self): os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(os.path.join(self.wigs, "tmp")) os.mkdir(os.path.join(self.out, "MasterTables")) gen_file(os.path.join(self.fastas, "tmp/test.fa"), "test") gen_file(os.path.join(self.gffs, "tmp/test.gff"), "test") gen_file( os.path.join(self.wigs, "tmp/test1_forward.wig_STRAIN_test.wig"), "test") gen_file( os.path.join(self.wigs, "tmp/test1_reverse.wig_STRAIN_test.wig"), "test") gen_file( os.path.join(self.wigs, "tmp/test1_TEX_forward.wig_STRAIN_test.wig"), "test") gen_file( os.path.join(self.wigs, "tmp/test1_TEX_reverse.wig_STRAIN_test.wig"), "test") libs = [ "test1_forward.wig:notex:1:a:+", "test1_reverse.wig:notex:1:a:-", "test1_TEX_forward.wig:tex:1:a:+", "test1_TEX_reverse.wig:tex:1:a:-" ] args = self.mock_args.mock() args.program = "TSS" args.height = 0.3 args.height_reduction = 0.2 args.factor = 2.0 args.factor_reduction = 0.5 args.base_height = 0.00 args.enrichment_factor = 2.0 args.processing_factor = 1.5 args.utr_length = 300 args.libs = libs args.out_folder = self.out args.cluster = 3 args.repmatch = ["all_2"] args.specify_strains = None args.output_prefixs = ["test1"] self.tss._set_gen_config(args, self.test_folder) datas = import_data(os.path.join(self.test_folder, "config_test.ini")) self.assertEqual("\n".join(datas), self.example.config) def test_convert_gff(self): os.mkdir(os.path.join(self.out, "gffs")) os.mkdir(os.path.join(self.out, "MasterTables")) os.mkdir(os.path.join(self.out, "MasterTables/MasterTable_test")) gen_file( os.path.join(self.out, "MasterTables/MasterTable_test/MasterTable.tsv"), self.example.master) args = self.mock_args.mock() args.out_folder = self.out args.program = "TSS" self.tss._convert_gff(["test"], args) datas = import_data(os.path.join(self.out, "gffs/test_TSS.gff")) self.assertEqual("\n".join(datas), self.example.master_gff) def test_merge_wigs(self): gen_file(os.path.join(self.wigs, "test1_forward.wig"), "test_f") gen_file(os.path.join(self.wigs, "test1_reverse.wig"), "test_r") gen_file(os.path.join(self.wigs, "test1_TEX_forward.wig"), "test_f") gen_file(os.path.join(self.wigs, "test1_TEX_reverse.wig"), "test_r") libs = [ "test1_forward.wig:notex:1:a:+", "test1_reverse.wig:notex:1:a:-", "test1_TEX_forward.wig:tex:1:a:+", "test1_TEX_reverse.wig:tex:1:a:-" ] self.tss._merge_wigs(self.wigs, "test", libs) datas = import_data(os.path.join("tmp", "merge_forward.wig")) self.assertEqual("\n".join(datas), "test_ftest_f") datas = import_data(os.path.join("tmp", "merge_reverse.wig")) self.assertEqual("\n".join(datas), "test_rtest_r") shutil.rmtree("tmp") def test_check_orphan(self): os.mkdir(os.path.join(self.out, "gffs")) gen_file(os.path.join(self.wigs, "test1_forward.wig"), "test_f") gen_file(os.path.join(self.wigs, "test1_reverse.wig"), "test_r") gen_file(os.path.join(self.wigs, "test1_TEX_forward.wig"), "test_f") gen_file(os.path.join(self.wigs, "test1_TEX_reverse.wig"), "test_r") ts.check_orphan = self.mock.mock_check_orphan libs = [ "test1_TEX_forward.wig:tex:1:a:+", "test1_TEX_reverse.wig:tex:1:a:-", "test1_forward.wig:notex:1:a:+", "test1_reverse.wig:notex:1:a:-" ] args = self.mock_args.mock() args.program = "TSS" args.gffs = self.gffs args.libs = libs self.tss._check_orphan(["test"], self.wigs, args) self.assertTrue( os.path.exists(os.path.join(self.out, "gffs/test_TSS.gff"))) def test_low_expression(self): ts.filter_low_expression = self.mock.mock_filter_low_expression gen_file(os.path.join(self.wigs, "test1_forward.wig"), "test_f") gen_file(os.path.join(self.wigs, "test1_reverse.wig"), "test_r") gen_file(os.path.join(self.wigs, "test1_TEX_forward.wig"), "test_f") gen_file(os.path.join(self.wigs, "test1_TEX_reverse.wig"), "test_r") gen_file(os.path.join(self.gffs, "test_TSS.gff"), self.example.tss_file) os.mkdir(os.path.join(self.out, "statistics")) os.mkdir(os.path.join(self.out, "statistics/test")) libs = [ "test1_TEX_forward.wig:tex:1:a:+", "test1_TEX_reverse.wig:tex:1:a:-", "test1_forward.wig:notex:1:a:+", "test1_reverse.wig:notex:1:a:-" ] args = self.mock_args.mock() args.manual = "manual" args.libs = libs args.wig_folder = self.wigs args.program = "TSS" args.cluster = 3 self.tss._low_expression(args, self.gffs) shutil.rmtree("tmp") datas = import_data( os.path.join( self.out, "statistics/test/stat_test_low_expression_cutoff.csv")) self.assertEqual("\n".join(datas), "Genome\tCutoff_coverage\ntest\t100") def test_merge_manual(self): gen_file(os.path.join(self.gffs, "test.gff"), self.example.tss_file) os.mkdir(os.path.join(self.out, "statistics")) os.mkdir(os.path.join(self.out, "statistics/test")) os.mkdir(os.path.join(self.out, "gffs")) ts.merge_manual_predict_tss = self.mock.mock_merge_manual_predict_tss args = self.mock_args.mock() args.gffs = self.gffs args.manual = "test_folder/manuals/tmp" os.mkdir(args.manual) gen_file("test_folder/manuals/tmp/test.gff", "test") args.wig_folder = self.wigs args.out_folder = self.out args.program = "TSS" args.utr_length = 300 args.libs = "libs" args.cluster = 3 self.tss._merge_manual(["test"], args) self.assertTrue( os.path.exists( os.path.join( self.out, "statistics/test/stat_compare_TSSpredator_manual_test.csv") )) self.assertTrue( os.path.exists(os.path.join(self.out, "gffs/test_TSS.gff"))) shutil.rmtree(args.manual) def test_deal_with_overlap(self): ts.filter_tss_pro = self.mock.mock_filter_tss_pro gen_file(os.path.join(self.out, "test_TSS.gff"), self.example.tss_file) gen_file(os.path.join(self.test_folder, "test_processing.gff"), self.example.tss_file) args = self.mock_args.mock() args.overlap_feature = "overlap" args.program = "TSS" args.cluster = 3 args.overlap_gffs = self.test_folder self.tss._deal_with_overlap(self.out, args) self.assertTrue(os.path.exists(os.path.join(self.out, "test_TSS.gff"))) def test_stat_tss(self): ts.stat_tsspredator = self.mock.mock_stat_tsspredator ts.plot_venn = self.mock.mock_plot_venn os.mkdir(os.path.join(self.out, "statistics")) os.mkdir(os.path.join(self.out, "statistics/test")) self.tss._stat_tss(["test"], "TSS") self.assertTrue( os.path.exists( os.path.join(self.out, "statistics/test/test_venn.png"))) self.assertTrue( os.path.exists( os.path.join(self.out, "statistics/test/test_class.png"))) def test_validate(self): gen_file(os.path.join(self.gffs, "test.gff"), self.example.tss_file) os.mkdir(os.path.join(self.out, "gffs")) ts.validate_gff = self.mock.mock_validate_gff args = self.mock_args.mock() args.gffs = self.gffs args.utr_length = 300 args.out_folder = self.out args.program = "tss" self.tss._validate(["test"], args) def test_compare_ta(self): self.tss.multiparser = self.mock_parser ts.stat_ta_tss = self.mock.mock_stat_ta_tss ta_path = os.path.join(self.trans, "tmp") os.mkdir(ta_path) os.mkdir(os.path.join(self.out, "gffs")) gen_file(os.path.join(ta_path, "test_transcript.gff"), self.example.tran_file) args = self.mock_args.mock() args.fuzzy = 3 args.trans = self.trans args.gffs = self.gffs self.tss._compare_ta(["test"], args) self.assertTrue( os.path.exists(os.path.join(self.trans, "test_transcript.gff"))) self.assertTrue( os.path.exists(os.path.join(self.out, "gffs/test_TSS.gff"))) def test_run_tsspredator(self): os.mkdir(os.path.join(self.out, "gffs")) os.mkdir(os.path.join(self.out, "statistics")) os.mkdir(os.path.join(self.out, "statistics/test")) os.mkdir(os.path.join(self.out, "MasterTables")) os.mkdir(os.path.join(self.out, "MasterTables/MasterTable_test")) os.mkdir(os.path.join(self.out, "configs")) ts.stat_tsspredator = self.mock.mock_stat_tsspredator ts.plot_venn = self.mock.mock_plot_venn ts.validate_gff = self.mock.mock_validate_gff ts.stat_ta_tss = self.mock.mock_stat_ta_tss ts.filter_tss_pro = self.mock.mock_filter_tss_pro ts.merge_manual_predict_tss = self.mock.mock_merge_manual_predict_tss ts.filter_low_expression = self.mock.mock_filter_low_expression ts.check_orphan = self.mock.mock_check_orphan self.tss._start_to_run = self.mock.mock_start_to_run gen_file(os.path.join(self.wigs, "test1_forward.wig"), self.example.wig_f) gen_file(os.path.join(self.wigs, "test1_reverse.wig"), self.example.wig_r) gen_file(os.path.join(self.wigs, "test1_TEX_forward.wig"), self.example.wig_f) gen_file(os.path.join(self.wigs, "test1_TEX_reverse.wig"), self.example.wig_r) gen_file(os.path.join(self.trans, "test_transcript.gff"), self.example.tran_file) gen_file(os.path.join(self.gffs, "test.gff"), self.example.gff_file) gen_file(os.path.join(self.fastas, "test.fa"), ">test\nAAATATATATATATAAATTTATATATATATA") libs = [ "test1_forward.wig:notex:1:a:+", "test1_reverse.wig:notex:1:a:-", "test1_TEX_forward.wig:tex:1:a:+", "test1_TEX_reverse.wig:tex:1:a:-" ] args = self.mock_args.mock() args.tsspredator_path = "test" args.program = "TSS" args.height = 0.3 args.height_reduction = 0.2 args.factor = 2.0 args.factor_reduction = 0.5 args.base_height = 0.00 args.enrichment_factor = 2.0 args.processing_factor = 1.5 args.utr_length = 300 args.libs = libs args.out_folder = self.out args.cluster = 3 args.repmatch = "all_2" args.output_prefixs = "test" args.check_orphan = True args.manual = "test_folder/manuals" args.remove_low_expression = True gen_file("test_folder/manuals/test.gff", self.example.tss_file) args.overlap_feature = "TSS" args.stat = True args.overlap_gffs = self.gffs args.validate = True args.fuzzy = 2 args.specify_strains = None self.tss.run_tsspredator(args) self.assertTrue( os.path.exists(os.path.join(self.out, "gffs/test_TSS.gff"))) self.assertTrue( os.path.exists( os.path.join( self.out, "statistics/test/stat_compare_TSSpredator_manual_test.csv") ))
class TestMergesRNA(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.example = Example() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_modify_attributes(self): pre_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 3, "end": 33, "phase": ".", "strand": "+", "score": "." } attributes_pre = {"ID": "sRNA0", "Name": "srna_0", "sRNA_type": "5utr"} tar1_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 3, "end": 33, "phase": ".", "strand": "+", "score": "." } attributes_tar1 = { "ID": "sRNA0", "Name": "srna_0", "sRNA_type": "antisense" } tar2_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 3, "end": 33, "phase": ".", "strand": "+", "score": "." } attributes_tar2 = { "ID": "sRNA0", "Name": "srna_0", "sRNA_type": "5utr" } pre = Create_generator(pre_dict, attributes_pre, "gff") tar1 = Create_generator(tar1_dict, attributes_tar1, "gff") ms.modify_attributes(pre, tar1, "UTR", "pre") self.assertEqual(pre.attributes["sRNA_type"], "5utr") pre = Create_generator(pre_dict, attributes_pre, "gff") tar2 = Create_generator(tar2_dict, attributes_tar2, "gff") ms.modify_attributes(pre, tar2, "UTR", "pre") self.assertEqual(pre.attributes["sRNA_type"], "5utr") pre = Create_generator(pre_dict, attributes_pre, "gff") tar1 = Create_generator(tar1_dict, attributes_tar1, "gff") ms.modify_attributes(pre, tar1, "UTR", "current") self.assertEqual(pre.attributes["sRNA_type"], "5utr") self.assertEqual(tar1.attributes["sRNA_type"], "5utr") def test_detect_overlap(self): pre_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 3, "end": 33, "phase": ".", "strand": "+", "score": "." } attributes_pre = {"ID": "sRNA0", "Name": "srna_0", "sRNA_type": "5utr"} tar1_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 3, "end": 33, "phase": ".", "strand": "+", "score": "." } attributes_tar1 = { "ID": "sRNA0", "Name": "srna_0", "sRNA_type": "3utr" } tar2_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 53, "end": 233, "phase": ".", "strand": "+", "score": "." } attributes_tar2 = { "ID": "sRNA0", "Name": "srna_0", "sRNA_type": "5utr" } pre = Create_generator(pre_dict, attributes_pre, "gff") tar1 = Create_generator(tar1_dict, attributes_tar1, "gff") tar2 = Create_generator(tar2_dict, attributes_tar2, "gff") overlap = False overlap = ms.detect_overlap(tar1, pre, "UTR", overlap) self.assertTrue(overlap) overlap = False overlap = ms.detect_overlap(tar2, pre, "UTR", overlap) self.assertFalse(overlap) def test_modify_overlap(self): pre_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 3, "end": 33, "phase": ".", "strand": "+", "score": "." } attributes_pre = { "ID": "sRNA0", "Name": "srna_0", "sRNA_type": "5utr", "with_TSS": "NA", "start_cleavage": "cleavage_1,cleavage_2", "end_cleavage": "NA" } tar_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 5, "end": 30, "phase": ".", "strand": "+", "score": "." } attributes_tar = { "ID": "sRNA0", "Name": "srna_0", "sRNA_type": "3utr", "with_TSS": "TSS_1", "start_cleavage": "cleavage3", "end_cleavage": "cleavage10" } pre = Create_generator(pre_dict, attributes_pre, "gff") tar = Create_generator(tar_dict, attributes_tar, "gff") pre_srna = ms.modify_overlap(pre, tar) self.assertEqual(pre_srna.attributes["with_TSS"], "TSS_1") self.assertEqual(pre_srna.attributes["start_cleavage"], "cleavage_1,cleavage_2,cleavage3") self.assertEqual(pre_srna.attributes["end_cleavage"], "cleavage10") self.assertEqual(pre_srna.start, 3) self.assertEqual(pre_srna.end, 33) def test_merge_srna(self): srnas = ms.merge_srna(self.example.srnas_utr, "UTR") self.assertEqual(len(srnas), 2) self.assertEqual(srnas[0].start, 3) self.assertEqual(srnas[1].start, 54) self.assertEqual(srnas[0].attributes["with_TSS"], "TSS_1") self.assertEqual(srnas[1].attributes["with_TSS"], "TSS_3") self.assertEqual(srnas[0].attributes["start_cleavage"], "cleavage_1,cleavage_2,cleavage_3") self.assertEqual(srnas[1].attributes["start_cleavage"], "cleavage_4") srnas = ms.merge_srna(self.example.srnas_int, "inter") self.assertEqual(srnas[0].attributes["with_TSS"], "TSS_1") self.assertEqual(srnas[1].attributes["with_TSS"], "NA") def test_merge_srna_gff(self): out_file = os.path.join(self.test_folder, "test_out") gen_file(os.path.join(self.test_folder, "aaa.gff"), self.example.gff_file) ms.read_gff = Mock_func().mock_read_gff gffs = {"merge": out_file, "utr": "UTR", "normal": "inter"} ms.merge_srna_gff(gffs, False, 0.5, os.path.join(self.test_folder, "aaa.gff")) datas, attributes = extract_info(out_file, "file") self.assertListEqual(datas, ['aaa\tANNOgesic\tncRNA\t54\t254\t.\t+\t.']) self.assertEqual( set(attributes[0]), set([ 'overlap_cds=NA', 'Name=sRNA_00000', 'ID=aaa_srna0', 'sRNA_type=intergenic', 'end_cleavage=cleavage_40', 'with_TSS=TSS_3', 'overlap_percent=NA' ])) def test_compare_table(self): ms.replicate_comparison = Mock_func().mock_replicate_comparison wigs = {"aaa": {"frag_1": {"track_1|+|frag": [100, 30, 23, 21, 21]}}} tables = [{ "strain": "aaa", "name": "sRNA_1", "start": 3, "end": 4, "strand": "+", "libs": "track_1", "detect": "True", "avg": 30, "high": 100, "low": 20, "detail": "detail" }] srna_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 3, "end": 4, "phase": ".", "strand": "+", "score": "." } attributes_srna = { "ID": "sRNA0", "Name": "srna_0", "sRNA_type": "3utr", "with_TSS": "TSS_1", "start_cleavage": "cleavage3", "end_cleavage": "cleavage10", "overlap_cds": "CDS1", "overlap_percent": "0.01415" } srna = Create_generator(srna_dict, attributes_srna, "gff") tss_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "TSS", "start": 3, "end": 3, "phase": ".", "strand": "+", "score": "." } attributes_tss = {"ID": "tss0", "Name": "TSS_0", "type": "Orphan"} tss = Create_generator(tss_dict, attributes_tss, "gff") out = StringIO() cutoff_tex = [0, 0, 0, 50, 20] cutoff_notex = [0, 0, 0, 30, 10] cutoff_frag = [400, 200, 0, 50, 30] gen_file("tmp_median", "aaa\t3utr\ttrack_1\t10") args = self.mock_args.mock() args.replicates = replicates = {"tex": 1, "frag": 1} args.texs = texs = {"track_tex_track_notex": 0} args.out_folder = os.getcwd() args.table_best = True args.tex_notex = 2 ms.compare_table(srna, tables, "utr", wigs, wigs, texs, out, [tss], args) self.assertEqual( out.getvalue(), "aaa\tsrna_0\t3\t4\t+\tfrag_1\t1\tTSS_1;cleavage3\tcleavage10\t22.0\t23\t21\ttrack_1(avg=22.0;high=23;low=21)\tCDS1\t0.01415\n" ) os.remove("tmp_median") def test_get_coverage(self): wigs = {"aaa": {"frag_1": {"track_1|+|frag": [100, 30, 23, 21, 21]}}} srna_cover = ms.get_coverage(wigs, self.example.srnas_int[0]) self.assertEqual(srna_cover["frag_1"], [{ 'low': 21, 'track': 'track_1', 'avg': 1.3548387096774193, 'final_end': 33, 'high': 21, 'pos': 0, 'final_start': 3, 'type': 'frag' }]) def test_get_tss_pro(self): srna_dict = { "seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 3, "end": 4, "phase": ".", "strand": "+", "score": "." } attributes_srna = { "ID": "sRNA0", "Name": "srna_0", "sRNA_type": "3utr", "with_TSS": "TSS_1", "start_cleavage": "cleavage3", "end_cleavage": "cleavage10" } srna = Create_generator(srna_dict, attributes_srna, "gff") tss_pro = ms.get_tss_pro("utr", srna) self.assertEqual(tss_pro, ('TSS_1;cleavage3', 'cleavage10'))
class TestSNPCalling(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" self.fasta = os.path.join(self.test_folder, "fasta") self.snp_folder = os.path.join(self.test_folder, "snp") self.table = os.path.join(self.test_folder, "table") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.fasta) os.mkdir(self.snp_folder) os.mkdir(self.table) os.mkdir( os.path.join(self.test_folder, "compare_related_and_reference_genomes")) os.mkdir( os.path.join(self.test_folder, "compare_related_and_reference_genomes/seqs")) os.mkdir( os.path.join( self.test_folder, "compare_related_and_reference_genomes/seqs/with_BAQ")) os.mkdir( os.path.join( self.test_folder, "compare_related_and_reference_genomes/statistics")) os.mkdir( os.path.join( self.test_folder, "compare_related_and_reference_genomes/SNP_raw_outputs")) args = self.mock_args.mock() args.types = "related_genome" args.out_folder = self.test_folder args.fastas = self.fasta self.snp = SNPCalling(args) self.mock = Mock_func() def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_transcript_snp(self): fasta = os.path.join(self.test_folder, "NC_007795.1.fa") gen_file(fasta, self.example.fasta) snp_folder = os.path.join( self.test_folder, "compare_related_and_reference_genomes/SNP_raw_outputs/test") os.mkdir(snp_folder) snp = os.path.join(snp_folder, "test_with_BAQ_NC_007795.1.vcf") gen_file(snp, self.example.snp) args = self.mock_args.mock() args.depth = 5 args.fraction = 0.3 args.quality = 2 args.depth_s = "n_10" args.depth_b = "a_2" args.dp4_sum = "n_10" args.dp4_frac = 0.5 args.idv = "n_10" args.imf = 0.5 args.filters = ["VDB_s0.1"] args.min_sample = 2 os.mkdir( os.path.join( self.test_folder, "compare_related_and_reference_genomes/seqs/with_BAQ/test")) depth_file = os.path.join(self.test_folder, "tmp_depthNC_007795.1") gen_file(depth_file, self.example.depth_file) bam_datas = [{ "sample": "NC_007795.1", "bam_number": 1, "bams": "test", "rep": 1 }] self.snp._transcript_snp( fasta, "test", "with", "test", bam_datas, self.table, args, ) datas = import_data( os.path.join( self.test_folder, "compare_related_and_reference_genomes/statistics/stat_test_with_BAQ_NC_007795.1_SNP_best.csv" )) print("\n".join(datas)) self.assertEqual("\n".join(datas), self.example.out_stat) datas = import_data( os.path.join( self.test_folder, "compare_related_and_reference_genomes/seqs/with_BAQ/test/test_NC_007795.1_NC_007795.1_1_1.fa" )) self.assertEqual("\n".join(datas), ">NC_007795.1\nAaTTGaaTCCCGAACGACAGTTAT") os.remove("test_NC_007795.1_seq_reference.csv") os.remove("test_NC_007795.1_best.vcf") os.remove("test_NC_007795.1_NC_007795.1_SNP_QUAL_best.png") os.remove("test_NC_007795.1_NC_007795.1_SNP_QUAL_raw.png") def test_run_program(self): self.snp._run_sub = self.mock.mock_run_sub args = self.mock_args.mock() bam_datas = [{ "sample": "NC_007795.1", "bam_number": 1, "bams": "test", "rep": 1 }] args.program = ["with_BAQ"] log = open(os.path.join(self.test_folder, "test.log"), "w") self.snp._run_program("fasta", bam_datas, args, log) self.assertTrue(os.path.exists(os.path.join(self.test_folder, "test"))) def test_merge_bams(self): args = self.mock_args.mock() args.frag_bams = os.path.join(self.test_folder, "frag_bams") args.normal_bams = os.path.join(self.test_folder, "tex_bams") os.mkdir(args.normal_bams) os.mkdir(args.frag_bams) bam_datas = [{ "sample": "NC_007795.1", "bam_number": 0, "bams": "test", "rep": 1 }] self.snp._run_bam = self.mock.mock_run_bam gen_file(os.path.join(args.normal_bams, "tex.bam"), "test") gen_file(os.path.join(args.normal_bams, "notex.bam"), "test") gen_file(os.path.join(args.frag_bams, "farg.bam"), "test") args.bams = [args.frag_bams, args.normal_bams] args.samtools_path = "test" log = open(os.path.join(self.test_folder, "test.log"), "w") self.snp._merge_bams(args, bam_datas, log) self.assertEqual(bam_datas[0]["bam_number"], 1) def test_modify_header(self): gen_file(os.path.join(self.fasta, "test.fa"), ">AAA|BBB|CCC|DDD|EEE\nAATTAATTGGCC") self.snp._modify_header(self.fasta) datas = import_data(os.path.join(self.fasta, "test.fa")) self.assertEqual("\n".join(datas), ">DDD\nAATTAATTGGCC") def test_get_genome_name(self): self.snp._get_header = self.mock.mock_get_header gen_file(os.path.join(self.test_folder, "header"), self.example.bam) args = self.mock_args.mock() args.samtools_path = "test" bam_datas = [{ "sample": "NC_007795.1", "bam_number": 0, "bams": "test", "rep": 1 }] seq_names = self.snp._get_genome_name(args, bam_datas) def test_run_snp_calling(self): self.snp._get_header = self.mock.mock_get_header self.snp._run_bam = self.mock.mock_run_bam self.snp._run_sub = self.mock.mock_run_sub self.snp._run_tools = self.mock.mock_run_tools self.snp._transcript_snp = self.mock.mock_transcript_snp gen_file(os.path.join(self.fasta, "test.fa"), ">AAA|BBB|CCC|DDD|EEE\nAATTAATTGGCC") gen_file(os.path.join(self.test_folder, "header"), self.example.bam) gen_file(os.path.join(self.test_folder, "whole_reads.bam"), "test") gen_file(os.path.join(self.test_folder, "whole_reads_sorted.bam"), "test") gen_file(os.path.join(self.test_folder, "tmp_bcf"), "test") gen_file(os.path.join(self.fasta, "all.fa.fai"), "test") args = self.mock_args.mock() args.types = "reference" args.program = ["with_BAQ"] args.bams = [ "a1:" + os.path.join(self.test_folder, "frag_bams"), "a2:" + os.path.join(self.test_folder, "tex_bams") ] args.frag_bams = os.path.join(self.test_folder, "frag_bams") args.normal_bams = os.path.join(self.test_folder, "tex_bams") os.mkdir(args.normal_bams) os.mkdir(args.frag_bams) gen_file(os.path.join(args.normal_bams, "tex.bam"), "test") gen_file(os.path.join(args.normal_bams, "notex.bam"), "test") gen_file(os.path.join(args.frag_bams, "farg.bam"), "test") args.samtools_path = "test" log = open(os.path.join(self.test_folder, "test.log"), "w") self.snp.run_snp_calling(args, log)
class TestPPI(unittest.TestCase): def setUp(self): self.test_folder = "test_folder" self.mock_args = MockClass() if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(os.path.join(self.test_folder, "tmp_specific")) os.mkdir(os.path.join(self.test_folder, "tmp_nospecific")) os.mkdir(os.path.join(self.test_folder, "with_strain")) os.mkdir(os.path.join(self.test_folder, "with_strain/test_ptt")) os.mkdir(os.path.join(self.test_folder, "without_strain")) os.mkdir(os.path.join(self.test_folder, "without_strain/test_ptt")) os.mkdir(os.path.join(self.test_folder, "all_results")) os.mkdir(os.path.join(self.test_folder, "best_results")) os.mkdir(os.path.join(self.test_folder, "figures")) self.ppi = PPINetwork(self.test_folder) self.mock = Mock_func() self.example = Example() def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_wget_id(self): self.ppi._run_wget = self.mock.mock_run_wget strain = "test_strain" locus = "test_locus" strain_id = { "ptt": "test_strain", "string": "string_test", "file": "file_test" } files = {"id_list": "test", "id_log": "test"} detect = self.ppi._wget_id(strain, locus, strain_id, files) self.assertTrue(detect) def test_retrieve_id(self): self.ppi._run_wget = self.mock.mock_run_wget strain_id = { "ptt": "test_strain", "string": "string_test", "file": "file_test" } files = {"id_list": "test", "id_log": "test"} genes = [{"strain": "test_strain", "locus_tag": "test_locus"}] self.ppi._retrieve_id(strain_id, genes, files) def test_get_prefer_name(self): row_a = "999.aaa" files = {"id_list": self.test_folder} gen_file(os.path.join(self.test_folder, "aaa"), "999.aaa\t222\t333\ttest_aaa") name = self.ppi._get_prefer_name(row_a, "test", files, "test") self.assertEqual(name, "test_aaa") def test_get_pubmed(self): out_all = StringIO() out_best = StringIO() out_noall = StringIO() out_nobest = StringIO() self.ppi._run_wget = self.mock.mock_run_wget files = { "id_list": self.test_folder, "id_log": "test", "pubmed_log": "test", "all_specific": out_all, "best_specific": out_best, "all_nospecific": out_noall, "best_nospecific": out_nobest } row = self.example.ppi_line.split("\t") strain_id = { "file": "test_file", "ptt": "test_ptt", "string": "test_string", "pie": "test_pie" } mode = "interaction" actor = "test_A" score = 11241 id_file = "SAOUHSC_01684" ptt = "test_ptt" gen_file(os.path.join(self.test_folder, "SAOUHSC_01684"), "93061.SAOUHSC_01684\t93061.SAOUHSC_01683\t333\ttest_aaa") gen_file(os.path.join(self.test_folder, "SAOUHSC_01683"), "93061.SAOUHSC_01683\t93061.SAOUHSC_01684\t333\ttest_bbb") paths = { "all": self.test_folder, "fig": self.test_folder, "best": self.test_folder } querys = "all" first_output = { "specific_all": True, "specific_best": True, "nospecific_all": True, "nospecific_best": True } args = self.mock_args.mock() args.out_folder = self.test_folder args.querys = "all" args.no_specific = True args.score = 19 self.ppi._get_pubmed(row, strain_id, mode, actor, id_file, first_output, ptt, files, paths, args) data = import_data( "test_folder/without_strain/test_ptt/test_aaa_test_bbb.csv") self.assertEqual("\n".join(data), self.example.with_out) data = import_data( "test_folder/with_strain/test_ptt/test_aaa_test_bbb.csv") self.assertEqual("\n".join(data), self.example.with_out) def test_merge_information(self): first_output = { "specific_all": True, "specific_best": True, "nospecific_all": True, "nospecific_best": True } out_all = StringIO() out_best = StringIO() row_a = self.example.ppi_line.split("\t") score = 111 id_file = "SAOUHSC_01684" id_folder = self.test_folder file_type = "specific" all_folder = os.path.join(self.test_folder, "with_strain") best_folder = os.path.join(self.test_folder, "without_strain") ptt = "test_ptt" filename = os.path.join(self.test_folder, "SAOUHSC_01684") gen_file(filename, "93061.SAOUHSC_01684\t1000\t333\ttest_aaa") self.ppi._merge_information(first_output, filename, out_all, out_best, row_a, score, id_file, id_folder, file_type, all_folder, best_folder, ptt) self.assertEqual(out_all.getvalue(), self.example.merge_out + "\n") self.assertEqual(out_best.getvalue(), self.example.merge_out + "\n") def test_detect_protein(self): gen_file(os.path.join(self.test_folder, "test"), self.example.ptt_file) strain_id = { "file": "test", "ptt": "test_ptt", "string": "test_string", "pie": "test_pie" } args = self.mock_args.mock() args.ptts = self.test_folder args.querys = "all" genes = self.ppi._detect_protein(strain_id, args) self.assertListEqual(genes, [{ 'strain': 'Staphylococcus_aureus_HG003', 'locus_tag': 'SAOUHSC_00001' }, { 'strain': 'Staphylococcus_aureus_HG003', 'locus_tag': 'SAOUHSC_00002' }, { 'strain': 'Staphylococcus_aureus_HG003', 'locus_tag': 'SAOUHSC_00003' }]) def test_setup_nospecific(self): out_all = StringIO() out_best = StringIO() out_noall = StringIO() out_nobest = StringIO() paths = { "all": os.path.join(self.test_folder, "all_results"), "fig": os.path.join(self.test_folder, "figures"), "best": os.path.join(self.test_folder, "best_results") } strain_id = { "file": "test", "ptt": "test_ptt", "string": "test_string", "pie": "test_pie" } files = { "id_list": self.test_folder, "id_log": "test", "pubmed_log": "test", "all_specific": out_all, "best_specific": out_best, "all_nospecific": out_noall, "best_nospecific": out_nobest } self.ppi._setup_nospecific(paths, strain_id, files) files["all_nospecific"].close() files["best_nospecific"].close() self.assertTrue( os.path.exists("test_folder/all_results/without_strain/test_ptt")) self.assertTrue( os.path.exists("test_folder/best_results/without_strain/test_ptt")) self.assertTrue( os.path.exists("test_folder/figures/without_strain/test_ptt")) def test_setup_folder_and_read_file(self): paths = { "all": os.path.join(self.test_folder, "all_results"), "fig": os.path.join(self.test_folder, "figures"), "best": os.path.join(self.test_folder, "best_results") } strain_id = { "file": "test.ptt", "ptt": "test_ptt", "string": "test_string", "pie": "test_pie" } files = { "id_list": self.test_folder, "id_log": "", "pubmed_log": "", "all_specific": "", "best_specific": "", "all_nospecific": "", "best_nospecific": "", "action_log": "" } gen_file(os.path.join(self.test_folder, "test.ptt"), self.example.ptt_file) args = self.mock_args.mock() args.querys = "all" args.no_specific = True args.out_folder = self.test_folder args.ptts = self.test_folder genes = self.ppi._setup_folder_and_read_file(strain_id, "", files, paths, args) for index in ("all_specific", "all_nospecific", "best_specific", "best_nospecific", "id_log", "action_log", "pubmed_log"): files[index].close() self.assertTrue(os.path.exists("test_folder/best_results/test")) self.assertTrue(os.path.exists("test_folder/all_results/test")) self.assertListEqual(genes, [{ 'locus_tag': 'SAOUHSC_00001', 'strain': 'Staphylococcus_aureus_HG003' }, { 'locus_tag': 'SAOUHSC_00002', 'strain': 'Staphylococcus_aureus_HG003' }, { 'locus_tag': 'SAOUHSC_00003', 'strain': 'Staphylococcus_aureus_HG003' }]) def test_wget_actions(self): gen_file(os.path.join(self.test_folder, "test.txt"), "93061\ttest") self.ppi._run_wget = self.mock.mock_run_wget files = { "id_list": self.test_folder, "id_log": "", "pubmed_log": "", "all_specific": "", "best_specific": "", "all_nospecific": "", "best_nospecific": "", "action_log": "" } strain_id = { "file": "test.ptt", "ptt": "test_ptt", "string": "test_string", "pie": "test_pie" } id_file = "test.txt" self.ppi._wget_actions(files, id_file, strain_id, self.test_folder) def test_retrieve_actions(self): self.ppi._run_wget = self.mock.mock_run_wget files = { "id_list": os.path.join(self.test_folder, "tmp_specific"), "id_log": "", "pubmed_log": "", "all_specific": "", "best_specific": "", "all_nospecific": "", "best_nospecific": "", "action_log": "" } strain_id = { "file": "test.ptt", "ptt": "test_ptt", "string": "test_string", "pie": "test_pie" } paths = { "all": os.path.join(self.test_folder, "all_results"), "fig": os.path.join(self.test_folder, "figures"), "best": os.path.join(self.test_folder, "best_results") } gen_file(os.path.join(self.test_folder, "tmp_specific/test.txt"), "93061\ttest") gen_file(os.path.join(self.test_folder, "tmp_action"), self.example.ppi_line) args = self.mock_args.mock() args.no_specific = True args.querys = "all" args.out_folder = self.test_folder self.ppi._retrieve_actions(files, strain_id, paths, args)
class TestsRNATargetPrediction(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.example = Example() self.mock = Mock_func() self.test_folder = "test_folder" self.gffs = "test_folder/gffs" self.srnas = "test_folder/srnas" self.out = "test_folder/output" self.fastas = "test_folder/fastas" self.seq = "test_folder/output/sRNA_seqs" self.rnaup = "test_folder/output/RNAup_results" self.rnaplex = "test_folder/output/RNAplex_results" self.merge = "test_folder/output/merged_results" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.gffs) os.mkdir(self.out) os.mkdir(self.srnas) os.mkdir(self.fastas) os.mkdir(self.rnaup) os.mkdir(self.rnaplex) os.mkdir(self.seq) os.mkdir(self.merge) os.mkdir(os.path.join(self.rnaup, "test")) args = self.mock_args.mock() args.out_folder = self.out args.srnas = self.srnas args.fastas = self.fastas args.gffs = self.gffs self.star = sRNATargetPrediction(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_sort_srna_fasta(self): fasta = os.path.join(self.fastas, "test.fa") gen_file(fasta, ">aaa\nAAAAAAAA\n>bbb\nCCCC\n>ccc\nGGGGGGGGGGGG") self.star._sort_srna_fasta(fasta, "test", self.test_folder) datas = import_data(os.path.join(self.test_folder, "tmp_srna_target_test_sRNA.fa")) self.assertListEqual(datas, ['>bbb', 'CCCC', '>aaa', 'AAAAAAAA', '>ccc', 'GGGGGGGGGGGG']) def test_read_fasta(self): fasta = os.path.join(self.fastas, "test.fa") gen_file(fasta, ">aaa\nAAAAAAAA") seq = self.star._read_fasta(fasta) self.assertEqual(seq, "AAAAAAAA") def test_get_specific_seq(self): srna_file = os.path.join(self.test_folder, "aaa_sRNA.gff") seq_file = os.path.join(self.test_folder, "aaa.fa") srna_out = os.path.join(self.test_folder, "out") gen_file(srna_file, self.example.srna_file) gen_file(seq_file, self.example.seq_file) self.star._get_specific_seq(srna_file, seq_file, srna_out, ["aaa:5:8:+"]) datas = import_data(srna_out) self.assertEqual("\n".join(datas), '>srna0|aaa|5|8|+\nTAAT') def test_gen_seq(self): srna_seq = os.path.join(self.out, "sRNA_seqs") tar_seq = os.path.join(self.out, "target_seqs") os.mkdir(os.path.join(self.srnas, "tmp")) os.mkdir(os.path.join(self.fastas, "tmp")) os.mkdir(os.path.join(self.gffs, "tmp")) os.mkdir(tar_seq) gen_file(os.path.join(self.srnas, "tmp", "aaa_sRNA.gff"), self.example.srna_file) gen_file(os.path.join(self.fastas, "tmp", "aaa.fa"), self.example.seq_file) gen_file(os.path.join(self.gffs, "tmp", "aaa.gff"), self.example.gff_file) args = self.mock_args.mock() args.query = ["aaa:5:8:+"] args.features = ["CDS"] args.tar_start = 3 args.tar_end = 5 self.star._gen_seq(["aaa"], args) datas = import_data(os.path.join(srna_seq, "aaa_sRNA.fa")) self.assertEqual("\n".join(datas), '>srna0|aaa|5|8|+\nTAAT') datas = import_data(os.path.join(tar_seq, "aaa_target_1.fa")) self.assertEqual("\n".join(datas), '>AAA_000001_cds0_12-16_+\nTAAATTCC') def test_rna_plex(self): self.star._run_rnaplex = self.mock.mock_run_rnaplex self.star._run_rnaplfold = self.mock.mock_run_rnaplfold os.mkdir("test_folder/test") gen_file("test_folder/test/test_RNAplex.txt", "test") gen_file(os.path.join(self.test_folder, "aaa_RNAplex.txt"), self.example.rnaplex) args = self.mock_args.mock() args.vienna_path = "test" args.win_size_s = 5 args.win_size_t = 5 args.span_s = 5 args.span_t = 5 args.unstr_region_rnaplex_s = 5 args.rnaplfold_path = None args.unstr_region_rnaplex_t = 5 log = open(os.path.join(self.test_folder, "test.log"), "w") self.star._rna_plex(["test"], args, log) datas = import_data("test_folder/test/test_RNAplex.txt") self.assertEqual("\n".join(datas), "test") def test_get_continue(self): out_rnaup = os.path.join(self.test_folder, "rnaup.txt") gen_file(out_rnaup, self.example.rnaup) srnas = self.star._get_continue(out_rnaup) self.assertListEqual(srnas, ["srna437"]) def test_rnaup(self): self.star._run_rnaup = self.mock.mock_run_rnaup gen_file(os.path.join(self.out, "sRNA_seqs/tmp_srna_target_test_sRNA.fa"), ">srna0|aaa|5|8|+\nAAATTAATTAAATTCCGGCCGGCCGG") gen_file(os.path.join(self.gffs, "test_target.fa"), ">AAA_000001|CDS_00000\nAAATTAATTAAATTCCGGCCGGCCGG") args = self.mock_args.mock() args.srnas = self.srnas args.fastas = self.fastas args.gffs = self.gffs args.vienna_path = "test" args.out_folder = self.out args.core_up = 4 log = open(os.path.join(self.test_folder, "test.log"), "w") self.star._rnaup(["test"], args, log) datas = import_data(os.path.join(self.out, "tmp_srna_target1.fa")) self.assertEqual("\n".join(datas), ">srna0|aaa|5|8|+\nAAATTAATTAAATTCCGGCCGGCCGG")
class TestOperonDetection(unittest.TestCase): def setUp(self): self.test_folder = "test_folder" self.mock_args = MockClass() self.mock = Mock_func() self.tsss = os.path.join(self.test_folder, "tsss") self.trans = os.path.join(self.test_folder, "trans") self.utr5s = os.path.join(self.test_folder, "utr5s") self.utr3s = os.path.join(self.test_folder, "utr3s") self.output = os.path.join(self.test_folder, "output") self.gffs = os.path.join(self.test_folder, "gffs") self.out_gff = os.path.join(self.output, "gffs") self.stat = os.path.join(self.test_folder, "stat") if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.gffs) os.mkdir(self.tsss) os.mkdir(self.stat) os.mkdir(os.path.join(self.tsss, "tmp")) os.mkdir(self.trans) os.mkdir(os.path.join(self.trans, "tmp")) os.mkdir(self.utr5s) os.mkdir(os.path.join(self.utr5s, "tmp")) os.mkdir(self.utr3s) os.mkdir(os.path.join(self.utr3s, "tmp")) os.mkdir(self.output) os.mkdir(self.out_gff) os.mkdir(os.path.join(self.output, "tables")) args = self.mock_args.mock() args.tsss = self.tsss args.trans = self.trans args.utr5s = self.utr5s args.utr3s = self.utr3s args.output_folder = self.output args.terms = None self.operon = OperonDetection(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_detect_operon(self): op.operon = self.mock.mock_operon gen_file(os.path.join(self.tsss, "tmp", "test_TSS.gff"), "test") gen_file(os.path.join(self.trans, "tmp", "test_transcript.gff"), "test") gen_file(os.path.join(self.gffs, "test.gff"), "test") args = self.mock_args.mock() args.gffs = self.out_gff args.term_fuzzy = 3 args.tss_fuzzy = 3 args.length = 100 self.operon._detect_operon(["test"], args) self.assertTrue( os.path.exists( os.path.join(self.output, "tables", "operon_test.csv"))) def test_stat(self): op.stat = self.mock.mock_stat table_file = os.path.join(self.output, "tables", "operon_test.csv") if not os.path.exists(table_file): gen_file(table_file, "test") self.operon._stat(os.path.join(self.output, "tables"), self.stat) self.assertTrue( os.path.exists(os.path.join(self.stat, "stat_operon_test.csv"))) def test_combine_gff(self): op.combine_gff = self.mock.mock_combine_gff gen_file(os.path.join(self.tsss, "tmp", "test_TSS.gff"), "test") gen_file(os.path.join(self.trans, "tmp", "test_transcript.gff"), "test") gen_file(os.path.join(self.gffs, "test.gff"), "test") gen_file(os.path.join(self.utr5s, "tmp", "test_5UTR.gff"), "test") gen_file(os.path.join(self.utr3s, "tmp", "test_3UTR.gff"), "test") args = self.mock_args.mock() args.gffs = self.out_gff args.term_fuzzy = 3 args.tss_fuzzy = 3 self.operon._combine_gff(["test"], args) self.assertTrue( os.path.exists(os.path.join(self.out_gff, "test_operon.gff")))
class TestRATT(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.test_folder = "test_folder" self.ref_embls = "test_folder/embls" self.output_path = "test_folder/output" self.tar_fastas = "test_folder/tar_fasta" self.ref_fastas = "test_folder/ref_fasta" self.gff_outfolder = "test_folder/gffs" self.ref_gbk = "test_folder/gbk" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.ref_embls) os.mkdir(self.ref_gbk) os.mkdir(self.output_path) os.mkdir(self.tar_fastas) os.mkdir(self.ref_fastas) os.mkdir(self.gff_outfolder) args = self.mock_args.mock() args.output_path = self.output_path args.ref_embls = self.ref_embls args.ref_gbk = self.ref_gbk args.tar_fastas = self.tar_fastas args.ref_fastas = self.ref_fastas args.gff_outfolder = self.gff_outfolder self.ratt = RATT(args) self.example = Example() def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_convert_to_pttrnt(self): files = ["aaa.gff"] log = open(os.path.join(self.test_folder, "test.log"), "w") gen_file(os.path.join(self.test_folder, "aaa.gff"), self.example.gff_file) os.mkdir(os.path.join(self.tar_fastas, "tmp")) gen_file(os.path.join(self.tar_fastas, "tmp/aaa.fa"), self.example.fasta_file) self.ratt._convert_to_pttrnt(self.test_folder, files, log) data = import_data(os.path.join(self.test_folder, "aaa.rnt")) self.assertEqual("\n".join(data), self.example.rnt_file) data = import_data(os.path.join(self.test_folder, "aaa.ptt")) self.assertEqual("\n".join(data), self.example.ptt_file) def test_convert_to_gff(self): files = ["aaa.gff"] log = open(os.path.join(self.test_folder, "test.log"), "w") ratt_result = "chromosome.aaa.final.embl" gen_file(os.path.join(self.output_path, ratt_result), self.example.embl_file) args = self.mock_args.mock() args.output_path = self.output_path args.gff_outfolder = self.gff_outfolder self.ratt._convert_to_gff(ratt_result, args, files, log) data = import_data(os.path.join(self.output_path, "aaa.gff")) self.assertEqual("\n".join(data), self.example.embl_gff) data = import_data(os.path.join(self.gff_outfolder, "aaa.gff")) self.assertEqual("\n".join(data), self.example.embl_gff) def test_parser_embl_gbk(self): files = [os.path.join(self.test_folder, "aaa.gbk")] gen_file(os.path.join(self.test_folder, "aaa.gbk"), self.example.gbk_file) self.ratt._parser_embl_gbk(files) data = import_data(os.path.join(self.ref_gbk, "gbk_tmp/NC_007795.1.gbk")) self.assertEqual( "\n".join(data), self.example.gbk_file.split("//")[0] + "//") data = import_data(os.path.join( self.ref_gbk, "gbk_tmp/NC_007799.1.gbk")) self.assertEqual( "\n".join(data), self.example.gbk_file.split("//")[1].strip() + "\n//") def test_convert_embl(self): gen_file(os.path.join(self.test_folder, "aaa.gbk"), self.example.gbk_file.split("//")[0]) log = open(os.path.join(self.test_folder, "test.log"), "w") out = self.ratt._convert_embl(self.test_folder, log) self.assertEqual(out, "test_folder/gbk/gbk_tmp") self.assertTrue(os.path.exists("test_folder/gbk/gbk_tmp")) def test_format_and_run(self): self.ratt._run_ratt = Mock_func().mock_run_ratt args = self.mock_args.mock() args.output_path args.pairs = ["NC_007795.1:Staphylococcus_aureus_HG003"] args.element = "chromosome" log = open(os.path.join(self.test_folder, "test.log"), "w") self.ratt._format_and_run(args, log) def test_annotation_transfer(self): gen_file(os.path.join(self.ref_fastas, "aaa.fa"), self.example.fasta_file) gen_file(os.path.join(self.tar_fastas, "bbb.fa"), self.example.fasta_file) gen_file(os.path.join(self.ref_embls, "aaa.gbk"), self.example.gbk_file.split("//")[0]) log = open(os.path.join(self.test_folder, "test.log"), "w") self.ratt._run_ratt = Mock_func().mock_run_ratt args = self.mock_args.mock() args.element = "element" args.ref_embls = self.ref_embls args.tar_fastas = self.tar_fastas args.ref_fastas = self.ref_fastas args.output_path = self.output_path args.gff_outfolder = self.gff_outfolder args.pairs = ["aaa:bbb"] args.convert = True self.ratt.annotation_transfer(args, log) self.assertTrue(os.path.exists( os.path.join(self.gff_outfolder, "bbb.gff"))) self.assertTrue(os.path.exists( os.path.join(self.gff_outfolder, "bbb.rnt"))) self.assertTrue(os.path.exists( os.path.join(self.gff_outfolder, "bbb.ptt")))
class TestsORFDetection(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.test_folder = "test_folder" self.fasta = "test_folder/fasta" self.wigs = "test_folder/wig" self.gff = "test_folder/gff" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.fasta) os.mkdir(self.wigs) os.mkdir(self.gff) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_get_coverage(self): coverages = { "3utr": "median", "5utr": "median", "inter": 5, "interCDS": "median" } medianlist = { "aaa": { "3utr": { "track_1": { "median": 3 } }, "5utr": { "track_1": { "median": 6 } }, "interCDS": { "track_1": { "median": 2 } }, "inter": { "track_1": { "median": 5 } } } } cutoffs = {"track_1": 0} sorf = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1] } covers = sd.get_coverage(sorf, self.example.wigs, "+", coverages, medianlist, cutoffs, 10) self.assertDictEqual( covers, { 'frag_1': [{ 'low': 2, 'avg': 33.4, 'high': 100, 'pos': 2, 'track': 'track_1', 'type': 'frag' }] }) def test_detect_rbs_site(self): args = self.mock_args.mock() args.max_len = 20 args.min_len = 3 args.fuzzy_rbs = 2 args.rbs_seq = ["AGGAGG"] detect = sd.detect_rbs_site("AGGAGGCCGCTATGCCACACGT", 2, self.example.tas[0], args) self.assertListEqual(detect, [1]) def test_detect_start_stop(self): seq = {"aaa": "TAGGAGGCCGCTATGCCATTA"} args = self.mock_args.mock() args.start_codon = ["ATG"] args.stop_codon = ["TTA"] args.max_len = 20 args.min_len = 3 args.fuzzy_rbs = 2 args.rbs_seq = ["AGGAGG"] args.multi_stop = True sorf = sd.detect_start_stop(self.example.tas, seq, args) self.assertListEqual(sorf, [{ 'strand': '+', 'type': 'intergenic', 'starts': ['13'], 'print': False, 'seq': 'ATGCCATTA', 'ends': ['21'], 'end': 21, 'start': 13, 'rbs': [2], 'strain': 'aaa' }]) seq = {"aaa": "TTAAAGGCATTATCCTCCTA"} self.example.tas[0].strand = "-" sorf = sd.detect_start_stop(self.example.tas, seq, args) self.assertListEqual(sorf, [{ 'end': 10, 'starts': ['2'], 'strain': 'aaa', 'ends': ['10'], 'type': 'intergenic', 'print': False, 'seq': 'TAAAGGCAT', 'rbs': [19], 'strand': '-', 'start': 2 }]) self.example.tas[0].strand = "+" def test_read_data(self): inter = os.path.join(self.test_folder, "inter") fasta = os.path.join(self.test_folder, "fa") gen_file(inter, self.example.inter) gen_file(fasta, ">aaa\nATATACCGATC") inters, tsss, srnas, seq = sd.read_data(inter, None, None, fasta, True) self.assertEqual(inters[0].start, 2) self.assertDictEqual(seq, {'aaa': 'ATATACCGATC'}) def test_check_tss(self): sorf = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1], "with_TSS": [] } checks = {"start": False, "rbs": False, "import": False} sd.check_tss(sorf, self.example.tsss[0], 300, checks) self.assertDictEqual(checks, { 'start': True, 'rbs': [1], 'import': True }) def test_compare_sorf_tss(self): sorfs = [{ "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1] }] args = self.mock_args.mock() args.utr_length = 300 args.noafter_tss = False args.no_tss = False sorfs_all, sorfs_best = sd.compare_sorf_tss(sorfs, self.example.tsss, "tss", args) self.assertListEqual(sorfs_all, [{ 'print': False, 'ends': ['10'], 'strand': '+', 'end': 6, 'type': '3utr', 'starts': ['2'], 'seq': 'ATGTA', 'strain': 'aaa', 'start': 2, 'rbs': [1], 'start_TSS': '1_+', 'with_TSS': ['TSS:1_+'] }]) self.assertListEqual(sorfs_best, [{ 'print': False, 'ends': ['10'], 'strand': '+', 'end': 6, 'type': '3utr', 'starts': ['2'], 'seq': 'ATGTA', 'strain': 'aaa', 'start': 2, 'rbs': [1], 'with_TSS': ['TSS:1_+'], 'start_TSS': '1_+' }]) def test_compare_sorf_srna(self): sorfs = [{ "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1] }] sd.compare_sorf_srna(sorfs, self.example.srnas, "test") self.assertListEqual(sorfs, [{ 'print': False, 'starts': ['2'], 'seq': 'ATGTA', 'strand': '+', 'srna': ['sRNA:5-8_+'], 'end': 6, 'rbs': [1], 'ends': ['10'], 'start': 2, 'strain': 'aaa', 'type': '3utr' }]) def test_import_overlap(self): sorf1 = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "srna": ["NA"], "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1], "start_TSS": "1" } sorf2 = { "strain": "aaa", "strand": "+", "start": 5, "end": 15, "srna": ["NA"], "starts": [str(5)], "ends": [str(15)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [2], "start_TSS": "2" } final = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "srna": ["NA"], "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1], "start_TSS": "1" } sd.import_overlap(sorf2, final, sorf1, True) self.assertDictEqual( final, { 'end': 15, 'candidate': ['2-6_TSS:1_RBS:1', '5-15_TSS:2_RBS:2'], 'start': 2, 'rbs': [1, 2], 'strand': '+', 'strain': 'aaa', 'print': False, 'seq': 'ATGTA', 'ends': ['10', '15'], "srna": ["NA"], 'start_TSS': '1', 'type': '3utr', 'starts': ['2', '5'] }) def test_merge(self): seq = {"aaa": "TAGGAGGCCGCTATGCCATTA"} sorfs = [{ "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1], "srna": ["sRNA1"], "start_TSS": "1" }, { "strain": "aaa", "strand": "+", "start": 5, "end": 15, "starts": [str(5)], "ends": [str(15)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [2], "srna": ["sRNA2"], "start_TSS": "2" }] finals = sd.merge(sorfs, seq) self.assertDictEqual( finals[0], { 'start_TSS': '1', 'rbs': [1, 2], 'strand': '+', 'strain': 'aaa', 'start': 2, 'candidate': ['2-6_TSS:1_RBS:1', '5-15_TSS:2_RBS:2'], 'ends': ['10', '6', '15'], 'starts': ['2', '5'], 'type': '3utr', 'end': 15, 'seq': 'AGGAGGCCGCTATG', "srna": ["sRNA1", "sRNA2"] }) def test_assign_utr_cutoff(self): coverages = { "3utr": "median", "5utr": 20, "interCDS": 11, "intergenic": 59 } medians = {"track": {"median": 50, "mean": 20}} cutoff = sd.assign_utr_cutoff(coverages, "3utr", medians, "track", 10) self.assertEqual(cutoff, 50) def test_get_cutoff(self): sorf = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1], "start_TSS": "1" } coverages = { "3utr": "median", "5utr": 20, "interCDS": 11, "intergenic": 59 } medians = {"aaa": {"3utr": {"track_1": {"median": 50, "mean": 20}}}} cutoff = sd.get_cutoff(sorf, "track_1", coverages, medians, 10) self.assertEqual(cutoff, 50) def test_get_attribute(self): sorf = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": ["1"], "start_TSS": "1", "with_TSS": "NA", "srna": "NA", "shift": 1 } string = sd.get_attribute(1, "sORF_1", "4", sorf, "utr") self.assertEqual( string, "ID=aaa_sorf1;Name=sORF_sORF_1;start_TSS=4;with_TSS=N,A;sORF_type=3utr;sRNA=N,A;rbs=1;frame_shift=1" ) def test_print_file(self): out_g = StringIO() out_t = StringIO() sorf = { "strain": "aaa", "strand": "+", "start": 10, "end": 15, "starts": [str(10)], "ends": [str(15)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": ["3"], "start_TSS": "1", "with_TSS": ["NA"], "srna": ["NA"], "candidate": ["AAA"], "shift": 1 } sorf_datas = { "best": 20, "high": 50, "low": 10, "start": 1, "end": 10, "track": "track_1", "detail": [], "conds": { "frag": "track_1" } } args = self.mock_args.mock() args.table_best = True args.print_all = True sd.print_file(sorf, sorf_datas, 1, out_g, out_t, "best", args) self.assertEqual( out_g.getvalue(), "aaa\tANNOgesic\tsORF\t10\t15\t.\t+\t.\tID=aaa_sorf1;Name=sORF_00001;start_TSS=1;with_TSS=NA;sORF_type=3utr;sRNA=NA;rbs=RBS_3;frame_shift=1\n" ) self.assertEqual( out_t.getvalue(), "aaa\tsORF_00001\t10\t15\t+\t3'UTR_derived\tNA\tRBS_3\t10\t15\tNA\t1\tFragmented\t20\t\tATGTA\tAAA\n" ) def test_print_table(self): out_t = StringIO() sorf = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": ["1"], "start_TSS": "1", "with_TSS": ["NA"], "srna": ["NA"], "candidate": ["AAA"], "shift": 1 } sorf_datas = { "best": 20, "high": 50, "low": 10, "start": 1, "end": 10, "track": "track_1", "detail": [], "conds": { "frag": "track_1" } } args = self.mock_args.mock() args.table_best = True args.print_all = True sd.print_table(out_t, sorf, "test", "3utr", "frag", sorf_datas, args) self.assertEqual( out_t.getvalue(), "aaa\tsORF_test\t2\t6\t+\t3utr\tNA\t1\t2\t10\tNA\t1\tfrag\t20\t\tATGTA\tAAA\n" ) def test_get_inter_coverage(self): inter_covers = {} inters = [{"frag": [{"track": "track_1", "avg": 22}]}] sd.get_inter_coverage(inters, inter_covers) self.assertDictEqual(inter_covers, {'track_1': [22]}) def test_detect_utr_type(self): ta_dict = [{ "seq_id": "aaa", "source": "intergenic", "feature": "Transcript", "start": 1, "end": 23, "phase": ".", "strand": "+", "score": "." }] attributes_tas = [{ "ID": "tran0", "Name": "Transcript_0", "UTR_type": "intergenic" }] tas = [] tas.append(Create_generator(ta_dict[0], attributes_tas[0], "gff")) sd.get_coverage = self.mock.mock_get_coverage med_inters = {"aaa": {"intergenic": []}} sd.detect_utr_type(tas[0], "intergenic", med_inters, "wigs", "+", "test") sd.get_coverage = get_coverage self.assertDictEqual(med_inters, {'aaa': {'intergenic': ["2"]}}) def test_median_score(self): num = sd.median_score([1, 3, 11, 42, 2, 32, 111], "p_0.5") self.assertEqual(num, 11) def test_mean_score(self): num = sd.mean_score([1, 3, 11, 42, 2, 32, 111]) self.assertEqual(num, 28.857142857142858) def test_validate_tss(self): sorf = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": ["1"], "start_TSS": "3", "with_TSS": ["TSS:3_+"], "srna": ["NA"], "candidate": ["AAA"] } datas = sd.validate_tss([2], [6], sorf, 300) self.assertEqual(datas, (['TSS:3_+'], 'NA')) def test_validate_srna(self): sorf = { "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": ["1"], "start_TSS": "1", "with_TSS": ["TSS:3_+"], "srna": ["sRNA:2-5_+"], "candidate": ["AAA"] } srnas = sd.validate_srna([2], [6], sorf) self.assertListEqual(srnas, ['sRNA:2-5_+']) def test_get_best(self): sorfs = [{ "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": ["1"], "start_TSS": "1", "with_TSS": ["TSS:3_+"], "srna": ["sRNA:2-5_+"], "candidate": ["2-6_TSS:3_RBS:1"] }] args = self.mock_args.mock() args.table_best = True args.no_srna = True args.utr_length = 300 data = sd.get_best(sorfs, "tss", "srna", args) self.assertListEqual(data, [{ 'type': '3utr', 'strand': '+', 'print': False, 'with_TSS': ['TSS:3_+'], 'starts': ['2'], 'start': 2, 'srna': ['sRNA:2-5_+'], 'rbs': ['1'], 'end': 6, 'seq': 'ATGTA', 'start_TSS': '1', 'strain': 'aaa', 'ends': ['10'], 'candidate': ['2-6_TSS:3_RBS:1'] }]) def test_coverage_and_output(self): out_t = StringIO() out_g = StringIO() sd.get_coverage = self.mock.mock_get_coverage sd.replicate_comparison = self.mock.mock_replicate_comparison sorfs = [{ "strain": "aaa", "strand": "+", "start": 10, "end": 15, "starts": [str(10)], "ends": [str(15)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": [1], "start_TSS": "1", "with_TSS": ["TSS:3_+"], "srna": ["sRNA:2-5_+"], "candidate": ["2-6_TSS:3_RBS:1"] }] seq = {"aaa": "TAGGAGGCCGCTATGCCATTA"} wigs = {"forward": "wigs_f", "reverse": "wigs_r"} args = self.mock_args.mock() args.print_all = True args.min_rbs = 0 args.max_rbs = 20 args.min_len = 0 args.max_len = 300 args.table_best = True args.background = 10 sd.coverage_and_output(sorfs, "median", wigs, out_g, out_t, "best", seq, "cover", args, "texs", "final") sd.get_coverage = copy.deepcopy(get_coverage) self.assertEqual(out_g.getvalue(), ( "##gff-version 3\naaa\tANNOgesic\tsORF\t10\t15\t." "\t+\t.\tID=aaa_sorf0;Name=sORF_00000;start_TSS=1;" "with_TSS=TSS:3_+;sORF_type=3utr;sRNA=NA;rbs=RBS_1;frame_shift=1\n" )) self.assertEqual(out_t.getvalue().split("\n")[1], ( "aaa\tsORF_00000\t10\t15\t+\t3'UTR_derived\tTSS:3_+" "\tRBS_1\t10\t15\tNA\t1\tFragmented\t20\t\tGCTATG\t10-15_TSS:3_+_RBS:1" )) def test_detect_inter_type(self): inter_dict = [{ "seq_id": "aaa", "source": "UTR_derived", "feature": "Transcript", "start": 1, "end": 23, "phase": ".", "strand": "+", "score": "." }] attributes_inter = [{ "ID": "tran0", "Name": "Transcript_0", "UTR_type": "3utr" }] inters = [] inters.append( Create_generator(inter_dict[0], attributes_inter[0], "gff")) sd.get_coverage = self.mock.mock_get_coverage wigs = {"forward": "wigs_f", "reverse": "wigs_r"} data = sd.detect_inter_type(inters, wigs, "test") self.assertDictEqual( data, {'aaa': { 'interCDS': [], '5utr': [], '3utr': ['2'] }}) sd.get_coverage = copy.deepcopy(get_coverage) def test_set_median(self): mediandict = {} covers = {"aaa": {"3utr": {"track_1": [1, 3, 4, 2, 55]}}} coverages = {"3utr": "p_0.5", "5utr": "p_0.5", "interCDS": "n_100"} sd.set_median(covers, mediandict, coverages) self.assertDictEqual( mediandict, { 'aaa': { '5utr': {}, 'interCDS': {}, '3utr': { 'track_1': { 'median': 3 } } } }) def test_compute_candidate_best(self): sorfs = [{ "strain": "aaa", "strand": "+", "start": 2, "end": 6, "starts": [str(2)], "ends": [str(10)], "seq": "ATGTA", "type": "3utr", "print": False, "rbs": ["1"], "start_TSS": "1", "with_TSS": ["TSS:3_+"], "srna": ["sRNA:2-5_+"] }] sd.compute_candidate_best(sorfs) self.assertListEqual(sorfs, [{ 'starts': ['2'], 'seq': 'ATGTA', 'strain': 'aaa', 'ends': ['10'], 'print': False, 'rbs': ['1'], 'type': '3utr', 'end': 6, 'start': 2, 'srna': ['sRNA:2-5_+'], 'candidate': ['2-6_TSS:1_RBS:1'], 'start_TSS': '1', 'strand': '+', 'with_TSS': ['TSS:3_+'] }]) def test_sorf_detection(self): fasta = os.path.join(self.fasta, "fasta") gen_file(fasta, ">aaa\nTAGGAGGCCGCTATGCCATTA") srna_gff = os.path.join(self.gff, "srna.gff") inter_gff = os.path.join(self.gff, "inter.gff") tss_file = os.path.join(self.gff, "tss.gff") sd.get_coverage = self.mock.mock_get_coverage sd.read_libs = self.mock.mock_read_libs sd.read_wig = self.mock.mock_read_wig sd.get_inter_coverage = self.mock.mock_get_inter_coverage gen_file(srna_gff, self.example.srna) gen_file(inter_gff, self.example.inter) gen_file(tss_file, self.example.tss) args = self.mock_args.mock() args.start_codon = ["ATG"] args.stop_codon = ["TTA"] args.cutoff_5utr = "p_0.5" args.cutoff_intercds = "n_20" args.cutoff_3utr = "n_11" args.cutoff_inter = 50 args.cutoff_anti = 50 args.libs = ["frag:frag:1:a:+"] args.merge_wigs = "wig_folder" args.utr_detect = True args.background = 10 args.print_all = True sd.sorf_detection(fasta, srna_gff, inter_gff, tss_file, "wig_f_file", "wig_r_file", "test_folder/test", args) sd.get_coverage = copy.deepcopy(get_coverage) sd.replicate_comparison = self.mock.mock_replicate_comparison self.assertTrue(os.path.exists("test_folder/test_all.csv")) self.assertTrue(os.path.exists("test_folder/test_all.gff")) self.assertTrue(os.path.exists("test_folder/test_best.csv")) self.assertTrue(os.path.exists("test_folder/test_best.gff"))
class TestConverter(unittest.TestCase): def setUp(self): self.converter = Converter() self.example = Example() self.converter.gff3parser = Mock_gff3_parser self.converter._print_rntptt_title = Mock_func().print_rntptt_title self.converter.tsspredator = Mock_TSSPredatorReader() self.converter._read_file = Mock_func().mock_read_file self.gff_file = self.example.gff_file self.ptt_out = self.example.ptt_out self.rnt_out = self.example.rnt_out self.srna_out = self.example.srna_out self.embl_file = self.example.embl_file self.embl_out = self.example.embl_out self.multi_embl = self.example.multi_embl self.gff_out = self.example.gff_out self.mastertable = self.example.mastertable self.tss_file = self.example.tss_file self.fasta_file = self.example.fasta_file self.transterm = self.example.transterm self.term_file = self.example.term_file self.circ_file = self.example.circrna_table self.circ_all = self.example.circrna_all self.circ_best = self.example.circrna_best self.test_folder = "test_folder" self.mock_args = MockClass() if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_print_rntptt_file(self): cdss = [] genes = [] rnas = [] gff_dict = Example().gff_dict for gff in gff_dict: if gff["feature"] == "gene": genes.append(self.converter.gff3parser.entries(self, gff)) elif gff["feature"] == "CDS": cdss.append(self.converter.gff3parser.entries(self, gff)) elif gff["feature"] == "tRNA": rnas.append(self.converter.gff3parser.entries(self, gff)) out_p = StringIO() out_r = StringIO() self.converter._print_rntptt_file(out_p, cdss, genes) self.converter._print_rntptt_file(out_r, rnas, genes) self.assertEqual(out_p.getvalue().split("\n")[:-1], self.ptt_out.split("\n")) self.assertEqual(out_r.getvalue().split("\n")[:-1], self.rnt_out.split("\n")) out_p.close() out_r.close() def test_srna2pttrnt(self): srna_input_file = os.path.join(self.test_folder, "srna.gff") srna_output_file = os.path.join(self.test_folder, "srna.out") with open(srna_input_file, "w") as fh: fh.write(self.gff_file) srnas = [] self.converter._srna2rntptt(srna_input_file, srna_output_file, srnas, 1234567) datas = import_data(srna_output_file) self.assertEqual(set(datas), set(self.srna_out.split("\n"))) def test_multi_embl_pos(self): embls = [] for line in self.embl_file.split("\n"): datas = self.converter._multi_embl_pos(line.strip()) if datas != "Wrong": embls.append(datas) for index in range(0, 7): self.assertDictEqual(embls[index], self.embl_out[index]) for index in range(0, 2): self.assertDictEqual(embls[-1]["pos"][index], self.multi_embl[index]) def test_parser_embl_data(self): embl_file = os.path.join(self.test_folder, "test.embl") embl_out = os.path.join(self.test_folder, "test.embl_out") out = StringIO() with open(embl_file, "w") as eh: for line in self.embl_file.split("\n"): eh.write(line + "\n") info = self.converter._parser_embl_data(embl_file, out) datas = out.getvalue().split("\n") self.assertEqual(set(datas[:-1]), set(self.gff_out.split("\n"))) self.assertEqual(info[0], "NC_007795.1") for index in range(0, 2): self.assertDictEqual(info[1]["pos"][index], self.multi_embl[index]) out.close() def test_multi_tss_class(self): nums = {"tss": 0, "tss_uni": 0, "class": 1} utrs = {"total": [], "pri": [], "sec": []} tss_features = {"tss_types": [], "locus_tags": [], "utr_lengths": []} tss_index = defaultdict(lambda: 0) master_file = os.path.join(self.test_folder, "test.tsv") fh = StringIO(self.mastertable) for tss in self.converter.tsspredator.entries(fh): self.converter._multi_tss_class(tss, tss_index, tss_features, nums, utrs) fh.close() self.assertDictEqual(nums, {'tss_uni': 0, 'class': 5, 'tss': 2}) def test_convert_mastertable2gff(self): master_file = os.path.join(self.test_folder, "test.tsv") with open(master_file, "w") as th: th.write(self.mastertable) out_gff = os.path.join(self.test_folder, "test.tsv_out") self.converter.convert_mastertable2gff(master_file, "ANNOgesic", "TSS", "aaa", out_gff) datas = import_data(out_gff) self.assertEqual(set(datas), set(self.tss_file.split("\n"))) def test_convert_gff2rntptt(self): srna_input_file = os.path.join(self.test_folder, "srna.gff") srna_output_file = os.path.join(self.test_folder, "srna.out") gff_file = os.path.join(self.test_folder, "test.gff") rnt_file = os.path.join(self.test_folder, "test.rnt") ptt_file = os.path.join(self.test_folder, "test.ptt") fasta_file = os.path.join(self.test_folder, "test.fa") with open(srna_input_file, "w") as fh: fh.write(self.gff_file) with open(gff_file, "w") as fh: fh.write(self.gff_file) with open(fasta_file, "w") as fh: fh.write(self.fasta_file) self.converter.convert_gff2rntptt(gff_file, fasta_file, ptt_file, rnt_file, srna_input_file, srna_output_file) self.assertTrue(srna_output_file) self.assertTrue(rnt_file) self.assertTrue(ptt_file) def test_convert_embl2gff(self): embl_file = os.path.join(self.test_folder, "test.embl") gff_file = os.path.join(self.test_folder, "test.embl_out") with open(embl_file, "w") as eh: for line in self.embl_file.split("\n"): eh.write(line + "\n") self.converter.convert_embl2gff(embl_file, gff_file) datas = import_data(gff_file) self.assertEqual(set(datas[1:-2]), set(self.gff_out.split("\n"))) def test_convert_transtermhp2gff(self): transterm_file = os.path.join(self.test_folder, "test_best_terminator_after_gene.bag") gff_file = os.path.join(self.test_folder, "transterm.gff") with open(transterm_file, "w") as th: th.write(self.transterm) self.converter.convert_transtermhp2gff(transterm_file, gff_file) datas = import_data(gff_file) self.assertEqual(set(datas), set(self.term_file.split("\n"))) def get_info(datas): f_datas = [] for data in datas: if not data.startswith("#"): f_datas.append("\t".join(data.split("\t")[:8])) return f_datas def test_convert_circ2gff(self): circ_file = os.path.join(self.test_folder, "circ.csv") out_all = os.path.join(self.test_folder, "all.gff") out_filter = os.path.join(self.test_folder, "best.gff") with open(circ_file, "w") as ch: ch.write(self.circ_file) args = self.mock_args.mock() args.start_ratio = 0.5 args.end_ratio = 0.5 args.support = 5 self.converter.convert_circ2gff(circ_file, args, out_all, out_filter) datas = import_data(out_all) f_datas = [] for data in datas: if not data.startswith("#"): f_datas.append("\t".join(data.split("\t")[:8])) c_datas = [] for data in self.circ_all.split("\n"): if not data.startswith("#"): c_datas.append("\t".join(data.split("\t")[:8])) self.assertListEqual(f_datas, c_datas) datas = import_data(out_filter) f_datas = [] for data in datas: if not data.startswith("#"): f_datas.append("\t".join(data.split("\t")[:8])) c_datas = [] for data in self.circ_best.split("\n"): if not data.startswith("#"): c_datas.append("\t".join(data.split("\t")[:8])) self.assertListEqual(f_datas, c_datas)
class TestsRNAUTR(unittest.TestCase): def setUp(self): self.example = Example() self.mock = Mock_func() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_import_data(self): pos = {"start": 4, "end": 40, "ori_start": 2, "ori_end": 3} datas = sud.import_data("+", "aaa", pos, "3UTR", "TSS", "cds", "srna_cover", "test") self.assertDictEqual( datas, { 'start_cleavage': 'NA', 'strand': '+', 'end_cleavage': 'test', 'start_tss': 'cds', 'end': 40, 'start': 4, 'utr': '3UTR', 'strain': 'aaa', 'datas': 'srna_cover' }) def test_read_data(self): args = self.mock_args.mock() args.gff_file = os.path.join(self.test_folder, "test.gff") args.ta_file = os.path.join(self.test_folder, "test.gff") args.tss_file = os.path.join(self.test_folder, "test.gff") args.pro_file = os.path.join(self.test_folder, "test.gff") args.seq_file = os.path.join(self.test_folder, "test.fa") gen_file(args.gff_file, self.example.gff_file) gen_file(args.seq_file, self.example.seq_file) args.hypo = False cdss, tas, tsss, pros, seq = sud.read_data(args) self.assertEqual(cdss[0].start, 4) self.assertEqual(tas[0].start, 4) self.assertEqual(tsss[0].start, 4) self.assertEqual(pros[0].start, 4) self.assertDictEqual(seq, { 'aaa': 'ATATGACGATACGTAAACCGACCGAATATATCTTTTCACAACCAGATTACGATCGTCAT' }) def test_get_terminal(self): inters = [] seq = { "aaa": "ATATGACGATACGTAAACCGACCGAATATATCTTTTCACAACCAGATTACGATCGTCAT" } sud.get_terminal(self.example.gffs, inters, seq, "start") self.assertListEqual(inters, [{ 'end': 4, 'len_CDS': 0, 'strand': '+', 'strain': 'aaa', 'start': 1 }]) def test_get_inter(self): inters = [] sud.get_inter(self.example.gffs, inters) self.assertListEqual(inters, [{ 'start': 14, 'strand': '+', 'end': 20, 'strain': 'aaa', 'len_CDS': 10 }]) def test_set_cover_and_point(self): covers = [2, 3, 4, 1, 6, 2, 8, 3, 5, 6, 7, 5, 2, 1] cover_results = {"covers": None, "check_point": None} pos = {"start": 2, "end": 6, "ori_start": 2, "ori_end": 3} sud.set_cover_and_point(cover_results, self.example.inters[0], covers, pos, 5) self.assertListEqual(cover_results["covers"], [2, 3, 4, 1, 6, 2, 8, 3, 5]) self.assertDictEqual(cover_results["check_point"], { 'srna_start': 0, 'utr_start': 2, 'utr_end': 3, 'srna_end': 12 }) def test_check_import_srna_covers(self): args = self.mock_args.mock() cover = {"type": "5utr"} datas = { "num": 0, "cover_tmp": { "total": 100, "ori_total": 200 }, "checks": { "detect_decrease": True }, "final_poss": { "start": 3, "end": 23 } } cover_results = { "cover_sets": { "high": 50, "low": 10 }, "srna_covers": { "cond_1": [] }, "utr_covers": { "cond_1": [] }, "type": "5utr", "intercds": "TSS" } args.min_len = 30 args.max_len = 500 pos = {"start": 1, "end": 25, "ori_start": 1, "ori_end": 25} sud.check_import_srna_covers(datas, cover_results, self.example.inters[0], "cond_1", "track", cover, pos, args, "5utr") self.assertDictEqual(datas["final_poss"], {'end': 23, 'start': 3}) self.assertDictEqual( cover_results["srna_covers"], { 'cond_1': [{ 'final_start': 3, 'high': 50, 'ori_avg': 8.0, 'final_end': 23, 'low': 10, 'type': '5utr', 'avg': 4, 'track': 'track' }] }) self.assertDictEqual(cover_results["utr_covers"], cover_results["srna_covers"]) datas["checks"] = {"detect_decrease": False} cover_results["srna_covers"] = {"cond_1": []} cover_results["utr_covers"] = {"cond_1": []} sud.check_import_srna_covers(datas, cover_results, self.example.inters[0], "cond_1", "track", cover, pos, args, "5utr") self.assertDictEqual(cover_results["srna_covers"], {'cond_1': []}) def test_check_pos(self): cover = {"pos": 4} check_point = { "utr_start": 1, "utr_end": 29, "srna_start": 3, "srna_end": 11 } checks = {"srna": False, "utr": False} sud.check_pos(cover, check_point, checks, 4) self.assertDictEqual(checks, {'srna': True, 'utr': True}) def test_get_cover_5utr(self): args = self.mock_args.mock() datas = { "num": 0, "cover_tmp": { "5utr": 0 }, "checks": { "detect_decrease": True }, "final_poss": { "start": 1, "end": 26 } } cover = 20 cover_sets = {"high": 50, "low": 10} args.decrease_utr = 50 args.fuzzy_utr = 2 go_out = sud.get_cover_5utr(datas, cover_sets, cover, self.example.inters[0], args, 10) self.assertDictEqual(datas["final_poss"], {'start': 1, 'end': 10}) self.assertEqual(datas["num"], 0) self.assertTrue(go_out) self.assertDictEqual(datas["cover_tmp"], {'5utr': 0}) self.assertDictEqual(cover_sets, {'high': 50, 'low': 10}) cover = 20 datas = { "num": 0, "cover_tmp": { "5utr": 30 }, "checks": { "detect_decrease": True }, "final_poss": { "start": 1, "end": 26 } } cover_sets = {"low": 10, "high": 50} args.decrease_utr = 0.5 go_out = sud.get_cover_5utr(datas, cover_sets, cover, self.example.inters[0], args, 10) self.assertEqual(datas["num"], 1) self.assertFalse(go_out) self.assertDictEqual(datas["final_poss"], {'start': 1, 'end': 26}) self.assertDictEqual(datas["cover_tmp"], {'5utr': 20}) self.assertDictEqual(cover_sets, {'low': 20, 'high': 50}) def test_detect_cover_utr_srna(self): sud.coverage_comparison = self.mock.mock_coverage_comparison cover_results = { "cover_sets": { "low": 10, "high": 50 }, "pos": { "low": 10, "high": 50 }, "covers": [20], "type": "5utr", "srna_covers": { "frag_1": [] }, "utr_covers": { "frag_1": [] }, "intercds": "TSS", "check_point": { "utr_start": 1, "utr_end": 29, "srna_start": 2, "srna_end": 25 } } datas = { "num": 0, "cover_tmp": { "total": 100, "ori_total": 200 }, "checks": { "detect_decrease": True }, "final_poss": { "start": 3, "end": 23 } } pos = {"start": 2, "end": 20, "ori_start": 1, "ori_end": 23} args = self.mock_args.mock() args.min_len = 30 args.max_len = 500 args.decrease_utr = 0.5 args.fuzzy_utr = 2 sud.detect_cover_utr_srna(cover_results, pos, self.example.inters[0], "frag_1", "track_1", args, "frag", 2, 20, "+") self.assertDictEqual( cover_results["srna_covers"], { 'frag_1': [{ 'low': 20, 'high': 50, 'track': 'track_1', 'final_start': 2, 'ori_avg': 0.8695652173913043, 'type': 'frag', 'final_end': 20, 'avg': 1.0526315789473684 }] }) self.assertDictEqual(cover_results["utr_covers"], cover_results["srna_covers"]) self.assertDictEqual(cover_results["cover_sets"], { 'best': 20, 'low': 20, 'high': 50 }) def test_get_coverage(self): sud.coverage_comparison = self.mock.mock_coverage_comparison sud.detect_cover_utr_srna = self.mock.mock_detect_cover_utr_srna pos = {"start": 2, "end": 20, "ori_start": 1, "ori_end": 25} args = self.mock_args.mock() args.min_len = 30 args.max_len = 500 args.decrease_utr = 0.5 args.fuzzy_utr = 2 srna_covers, utr_covers = sud.get_coverage(self.example.wigs, self.example.inters[0], pos, "3utr", "TSS", args) self.assertDictEqual( srna_covers, { 'frag_1': [{ 'track': 'track_1', 'high': 50, 'final_start': 2, 'type': 'frag', 'avg': 8.052631578947368, 'low': 10, 'final_end': 3, 'ori_avg': 2.12 }] }) self.assertDictEqual(utr_covers, srna_covers) def test_get_utr_cutoff(self): mediandict = {"aaa": {"5utr": {"bbb": {}}}} avgs = [30, 60, 550, 302, 44] sud.get_utr_cutoff("p_0.5", mediandict, avgs, "aaa", "5utr", "bbb") self.assertDictEqual( mediandict, {'aaa': { '5utr': { 'bbb': { 'mean': 197.2, 'median': 60 } } }}) def test_detect_normal(self): sud.get_coverage = self.mock.mock_get_coverage diff = 50 pos = {"start": 2, "end": 20, "ori_start": 1, "ori_end": 25} args = self.mock_args.mock() args.min_len = 30 args.max_len = 500 args.decrease_utr = 0.5 args.fuzzy_utr = 2 args.utrs = [] args.srnas = [] sud.detect_normal(diff, self.example.wigs, self.example.inters[0], pos, "3utr", self.example.tsss[0], args) self.assertListEqual(args.srnas, [{ 'end': 20, 'strand': '+', 'datas': { 'frag_1': [{ 'track': 'track_1', 'final_start': 2, 'avg': 41.36842105263158, 'high': 50, 'type': 'frag', 'final_end': 20, 'ori_avg': 27.52, 'low': 10 }] }, 'end_cleavage': 'NA', 'utr': '3utr', 'start_cleavage': 'NA', 'strain': 'aaa', 'start': 2, 'start_tss': 'TSS:1_+' }]) self.assertListEqual(args.utrs, [{ 'end': 20, 'strand': '+', 'datas': { 'frag_1': [{ 'track': 'track_1', 'final_start': 2, 'avg': 41.36842105263158, 'high': 50, 'type': 'frag', 'final_end': 20, 'ori_avg': 27.52, 'low': 10 }] }, 'end_cleavage': 'NA', 'utr': '3utr', 'start_cleavage': 'NA', 'strain': 'aaa', 'start': 2, 'start_tss': 'NA' }]) args.utrs = [] args.srnas = [] args.pros = self.example.pros args.min_len = 3 args.max_len = 20 pos = {"start": 2, "end": 24, "ori_start": 1, "ori_end": 25} sud.detect_normal(diff, self.example.wigs, self.example.inters[0], pos, "3utr", self.example.tsss[0], args) self.assertListEqual(args.srnas, [{ 'start': 1, 'end': 18, 'start_tss': 'TSS:1_+', 'datas': { 'frag_1': [{ 'ori_avg': 27.52, 'track': 'track_1', 'high': 50, 'low': 10, 'type': 'frag', 'final_end': 20, 'avg': 41.36842105263158, 'final_start': 2 }] }, 'start_cleavage': 'NA', 'end_cleavage': 'Cleavage:18_+', 'utr': '3utr', 'strand': '+', 'strain': 'aaa' }]) sud.get_coverage = get_coverage def test_detect_3utr_pro(self): sud.get_coverage = self.mock.mock_get_coverage args = self.mock_args.mock() args.min_len = 1 args.max_len = 300 args.decrease_utr = 0.5 args.fuzzy_utr = 1 args.fuzzy_tsss = {"3utr": 3} args.pros = self.example.pros args.utrs = [] args.srnas = [] pos = {"start": 2, "end": 20, "ori_start": 1, "ori_end": 25} sud.detect_3utr_pro(self.example.inters[0], pos, self.example.wigs, "3utr", args) self.assertListEqual(args.srnas, [{ 'end_cleavage': 'NA', 'end': 20, 'start_cleavage': 'Cleavage:18_+', 'utr': '3utr', 'datas': { 'frag_1': [{ 'low': 10, 'final_start': 2, 'track': 'track_1', 'type': 'frag', 'final_end': 20, 'avg': 41.36842105263158, 'ori_avg': 27.52, 'high': 50 }] }, 'strand': '+', 'start_tss': 'NA', 'start': 18, 'strain': 'aaa' }]) self.assertListEqual(args.utrs, [{ 'end_cleavage': 'NA', 'end': 20, 'start_cleavage': 'NA', 'utr': '3utr', 'datas': { 'frag_1': [{ 'low': 10, 'final_start': 2, 'track': 'track_1', 'type': 'frag', 'final_end': 20, 'avg': 41.36842105263158, 'ori_avg': 27.52, 'high': 50 }] }, 'strand': '+', 'start_tss': 'NA', 'start': 18, 'strain': 'aaa' }]) sud.get_coverage = get_coverage def test_detect_twopro(self): sud.get_coverage = self.mock.mock_get_coverage pro_dict = [{ "seq_id": "aaa", "source": "tsspredator", "feature": "processing", "start": 18, "end": 18, "phase": ".", "strand": "+", "score": "." }, { "seq_id": "aaa", "source": "tsspredator", "feature": "processing", "start": 38, "end": 38, "phase": ".", "strand": "+", "score": "." }] attributes_pro = [{ "ID": "processing0", "Name": "Processing_0" }, { "ID": "processing1", "Name": "Processing_1" }] pros = [] for index in range(0, 2): pros.append( Create_generator(pro_dict[index], attributes_pro[index], "gff")) args = self.mock_args.mock() args.min_len = 1 args.max_len = 300 args.decrease_utr = 0.5 args.fuzzy_utr = 3 args.fuzzy_tsss = {"3utr": 3} args.pros = pros args.utrs = [] args.srnas = [] pos = {"start": 2, "end": 50, "ori_start": 1, "ori_end": 25} sud.detect_twopro(self.example.inters[0], pos, self.example.wigs, "interCDS", "interCDS", args) self.assertListEqual(args.srnas, [{ 'start_cleavage': 'Cleavage:18_+', 'utr': 'interCDS', 'datas': { 'frag_1': [{ 'type': 'frag', 'low': 10, 'final_start': 2, 'high': 50, 'avg': 41.36842105263158, 'final_end': 20, 'track': 'track_1', 'ori_avg': 27.52 }] }, 'start_tss': 'NA', 'end_cleavage': 'Cleavage:38_+', 'strand': '+', 'end': 38, 'strain': 'aaa', 'start': 18 }]) self.assertListEqual(args.utrs, [{ 'start_cleavage': 'NA', 'utr': 'interCDS', 'datas': { 'frag_1': [{ 'type': 'frag', 'low': 10, 'final_start': 2, 'high': 50, 'avg': 41.36842105263158, 'final_end': 20, 'track': 'track_1', 'ori_avg': 27.52 }] }, 'start_tss': 'NA', 'end_cleavage': 'Cleavage:38_+', 'strand': '+', 'end': 38, 'strain': 'aaa', 'start': 18 }]) sud.get_coverage = get_coverage def test_run_utr_detection(self): args = self.mock_args.mock() args.min_len = 1 args.max_len = 300 args.decrease_utr = 0.5 args.fuzzy_utr = 2 args.fuzzy_tsss = {"5utr": "n_3"} args.utrs = [] args.srnas = [] args.tsss = self.example.tsss args.pros = self.example.pros sud.get_coverage = self.mock.mock_get_coverage sud.run_utr_detection(self.example.wigs, self.example.inters[0], 2, 50, "5utr", args) sud.get_coverage = get_coverage self.assertListEqual(args.srnas, [{ 'start': 1, 'end': 50, 'start_cleavage': 'NA', 'datas': { 'frag_1': [{ 'high': 50, 'final_end': 20, 'avg': 41.36842105263158, 'low': 10, 'ori_avg': 27.52, 'final_start': 2, 'type': 'frag', 'track': 'track_1' }] }, 'start_tss': 'TSS:1_+', 'strain': 'aaa', 'strand': '+', 'utr': '5utr', 'end_cleavage': 'NA' }]) self.assertListEqual(args.utrs, [{ 'start': 1, 'end': 50, 'start_cleavage': 'NA', 'datas': { 'frag_1': [{ 'high': 50, 'final_end': 20, 'avg': 41.36842105263158, 'low': 10, 'ori_avg': 27.52, 'final_start': 2, 'type': 'frag', 'track': 'track_1' }] }, 'start_tss': 'NA', 'strain': 'aaa', 'strand': '+', 'utr': '5utr', 'end_cleavage': 'NA' }]) def test_class_utr(self): args = self.mock_args.mock() args.min_len = 1 args.max_len = 300 args.decrease_utr = 0.5 args.fuzzy_utr = 2 args.fuzzy_tsss = {"3utr": "p_3"} args.utrs = [] args.srnas = [] args.tsss = self.example.tsss args.pros = self.example.pros args.wig_fs = self.example.wigs sud.get_coverage = self.mock.mock_get_coverage sud.class_utr(self.example.inters[0], self.example.tas[0], args, args.wig_fs, args.wig_fs) sud.get_coverage = get_coverage self.assertListEqual(args.srnas, [{ 'end_cleavage': 'NA', 'start_tss': 'TSS:1_+', 'utr': '3utr', 'start_cleavage': 'NA', 'end': 20, 'start': 1, 'datas': { 'frag_1': [{ 'ori_avg': 27.52, 'final_start': 2, 'avg': 41.36842105263158, 'track': 'track_1', 'type': 'frag', 'final_end': 20, 'low': 10, 'high': 50 }] }, 'strain': 'aaa', 'strand': '+' }, { 'end_cleavage': 'NA', 'start_tss': 'NA', 'utr': '3utr', 'start_cleavage': 'Cleavage:18_+', 'end': 20, 'start': 18, 'datas': { 'frag_1': [{ 'ori_avg': 27.52, 'final_start': 2, 'avg': 41.36842105263158, 'track': 'track_1', 'type': 'frag', 'final_end': 20, 'low': 10, 'high': 50 }] }, 'strain': 'aaa', 'strand': '+' }]) self.assertListEqual(args.utrs, [{ 'end_cleavage': 'NA', 'start_tss': 'NA', 'utr': '3utr', 'start_cleavage': 'NA', 'end': 20, 'start': 1, 'datas': { 'frag_1': [{ 'ori_avg': 27.52, 'final_start': 2, 'avg': 41.36842105263158, 'track': 'track_1', 'type': 'frag', 'final_end': 20, 'low': 10, 'high': 50 }] }, 'strain': 'aaa', 'strand': '+' }, { 'end_cleavage': 'NA', 'start_tss': 'NA', 'utr': '3utr', 'start_cleavage': 'NA', 'end': 20, 'start': 18, 'datas': { 'frag_1': [{ 'ori_avg': 27.52, 'final_start': 2, 'avg': 41.36842105263158, 'track': 'track_1', 'type': 'frag', 'final_end': 20, 'low': 10, 'high': 50 }] }, 'strain': 'aaa', 'strand': '+' }]) def test_get_utr_coverage(self): utrs = [{ 'strand': '+', 'utr': '3utr', 'end': 20, 'start': 18, 'start_tss': 'NA', 'datas': { 'frag_1': [{ 'final_end': 20, 'track': 'track_1', 'final_start': 2, 'ori_avg': 27.52, 'avg': 41.36842105263158, 'type': 'frag', 'low': 10, 'high': 50 }] }, 'end_cleavage': 'NA', 'strain': 'aaa', 'start_cleavage': 'NA' }] covers = sud.get_utr_coverage(utrs) self.assertDictEqual(covers, { 'aaa': { 'interCDS': {}, '3utr': { 'track_1': [27.52] }, '5utr': {} } }) def test_set_cutoff(self): args = self.mock_args.mock() args.texs = {"track_4@AND@track_6": 0} covers = { 'aaa': { '5utr': { 'track_4': [52, 11, 23] }, 'inter': { 'track_3': [111] }, 'total': { 'track_1': [27.52, 111] }, '3utr': { 'track_1': [27.52, 111] }, 'interCDS': { 'track_2': [12, 0] } } } args.coverages = {"5utr": "p_0.3", "3utr": "n_10", "interCDS": "p_0.5"} args.cover_notex = { "5utr": "p_0.3", "3utr": "n_10", "interCDS": "p_0.5" } mediandict = sud.set_cutoff(covers, args) self.assertDictEqual( mediandict, { 'aaa': { '5utr': { 'track_4': { 'median': 11, 'mean': 28.666666666666668 } }, 'interCDS': { 'track_2': {} }, '3utr': { 'track_1': {} } } }) args.cover_notex = None mediandict = sud.set_cutoff(covers, args) self.assertDictEqual( mediandict, { 'aaa': { '3utr': { 'track_1': { 'mean': 69.26, 'median': 10.0 } }, '5utr': { 'track_4': { 'mean': 28.666666666666668, 'median': 11 } }, 'interCDS': { 'track_2': { 'mean': 6.0, 'median': 0 } } } }) def test_mean_score(self): lst = [1, 3, 5, 6, 7, 8] mean = sud.mean_score(lst) self.assertEqual(mean, 5.0) def test_median_score(self): lst = [1, 3, 5, 6, 7, 8] median = sud.median_score(lst, 0.5) self.assertEqual(median, 5) def test_detect_srna(self): sud.replicate_comparison = self.mock.mock_replicate_comparison args = self.mock_args.mock() args.min_len = 1 args.max_len = 300 args.decrease_utr = 0.5 args.fuzzy_utr = 2 args.coverages = "cover" args.texs = "template_texs" args.tex_notex = "tex_notex" args.replicates = "rep" args.table_best = True args.out = StringIO() args.out_t = StringIO() median = {"aaa": {"3utr": 555}} args.srnas = [{ 'strand': '+', 'utr': '3utr', 'end': 20, 'start': 18, 'start_tss': 'NA', 'datas': { 'frag_1': [{ 'final_end': 20, 'track': 'track_1', 'final_start': 2, 'ori_avg': 27.52, 'avg': 41.36842105263158, 'type': 'frag', 'low': 10, 'high': 50, "conds": ["frag"] }] }, 'end_cleavage': 'NA', 'strain': 'aaa', 'start_cleavage': 'Cleavage:18_+' }] sud.detect_srna(median, args) self.assertEqual( args.out.getvalue(), "aaa\tANNOgesic\tncRNA\t18\t20\t.\t+\t.\tID=aaa_srna_utr0;Name=UTR_sRNA_00000;sRNA_type=3utr;best_avg_coverage=500;best_high_coverage=700;best_low_coverage=400;with_TSS=NA;start_cleavage=Cleavage:18_+;end_cleavage=NA\n" ) self.assertEqual( args.out_t.getvalue(), "aaa\t00000\t18\t20\t+\tfrag_1\ttrack_1\t500\t700\t400\tfrag(avg=500;high=700;low=400)\n" ) def test_print_file(self): args = self.mock_args.mock() args.min_len = 1 args.max_len = 300 args.decrease_utr = 0.5 args.fuzzy_utr = 2 args.coverages = "cover" args.texs = "template_texs" args.tex_notex = "tex_notex" args.replicates = "rep" args.table_best = True args.out = StringIO() args.out_t = StringIO() srna = { 'strand': '+', 'utr': '3utr', 'end': 20, 'start': 18, 'start_tss': 'NA', 'datas': { 'frag_1': [{ 'final_end': 20, 'track': 'track_1', 'final_start': 2, 'ori_avg': 27.52, 'avg': 41.36842105263158, 'type': 'frag', 'low': 10, 'high': 50, "conds": ["frag"] }] }, 'end_cleavage': 'NA', 'strain': 'aaa', 'start_cleavage': 'Cleavage:18_+' } srna_datas = { "best": 500, "track": "frag", "high": 700, "low": 400, "start": 100, "end": 202, "conds": { "frag_1": "track_1" } } sud.print_file(0, srna, 2, 50, srna_datas, args) self.assertEqual( args.out.getvalue(), "aaa\tANNOgesic\tncRNA\t2\t50\t.\t+\t.\tID=aaa_srna_utr0;Name=UTR_sRNA_00000;sRNA_type=3utr;best_avg_coverage=500;best_high_coverage=700;best_low_coverage=400;with_TSS=NA;start_cleavage=Cleavage:18_+;end_cleavage=NA\n" ) self.assertEqual( args.out_t.getvalue(), "aaa\t00000\t2\t50\t+\tfrag_1\ttrack_1\t500\t700\t400\tfrag(avg=500;high=700;low=400)\n" )
class TestsTSSpredator(unittest.TestCase): def setUp(self): self.mock_args = MockClass() self.mock = Mock_func() self.mock_parser = Mock_Multiparser() self.example = Example() self.test_folder = "test_folder" self.trans = "test_folder/trans" self.out = "test_folder/output" self.gffs = "test_folder/gffs" self.tsss = "test_folder/tsss" self.terms = "test_folder/terms" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.trans) os.mkdir(os.path.join(self.trans, "tmp")) os.mkdir(self.out) os.mkdir(self.gffs) os.mkdir(self.tsss) os.mkdir(os.path.join(self.tsss, "tmp")) os.mkdir(self.terms) args = self.mock_args.mock() args.tsss = self.tsss args.trans = self.trans args.out_folder = self.out self.utr = UTRDetection(args) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_compute_utr(self): ut.detect_5utr = self.mock.mock_detect_5utr ut.detect_3utr = self.mock.mock_detect_3utr term_path = os.path.join(self.terms, "tmp") os.mkdir(term_path) utr5_path = os.path.join(self.out, "5UTRs") utr3_path = os.path.join(self.out, "3UTRs") os.mkdir(utr5_path) os.mkdir(utr3_path) os.mkdir(os.path.join(utr5_path, "gffs")) os.mkdir(os.path.join(utr3_path, "gffs")) utr5_stat_path = os.path.join(utr5_path, "statistics") utr3_stat_path = os.path.join(utr3_path, "statistics") os.mkdir(utr5_stat_path) os.mkdir(utr3_stat_path) gen_file(os.path.join(self.gffs, "test.gff"), self.example.gff_file) gen_file(os.path.join(self.trans, "test_transcript.gff"), self.example.tran_file) gen_file(os.path.join(self.tsss, "test_TSS.gff"), self.example.tss_file) gen_file(os.path.join(term_path, "test_term.gff"), self.example.term_file) args = self.mock_args.mock() args.gffs = self.gffs args.tsss = self.tsss args.trans = self.trans args.terms = self.terms log = open(os.path.join(self.test_folder, "test.log"), "w") self.utr._compute_utr(args, log) self.assertTrue( os.path.exists(os.path.join(utr5_stat_path, "test_5utr_length.png"))) self.assertTrue( os.path.exists(os.path.join(utr3_stat_path, "test_3utr_length.png"))) shutil.rmtree(utr5_path) shutil.rmtree(utr3_path) def test_run_utr_detection(self): self.utr._check_gff = self.mock.mock_check_gff ut.detect_5utr = self.mock.mock_detect_5utr ut.detect_3utr = self.mock.mock_detect_3utr utr5_path = os.path.join(self.out, "5UTRs") utr3_path = os.path.join(self.out, "3UTRs") os.mkdir(utr5_path) os.mkdir(utr3_path) os.mkdir(os.path.join(utr5_path, "gffs")) os.mkdir(os.path.join(utr3_path, "gffs")) utr5_stat_path = os.path.join(utr5_path, "statistics") utr3_stat_path = os.path.join(utr3_path, "statistics") os.mkdir(utr5_stat_path) os.mkdir(utr3_stat_path) gen_file(os.path.join(self.gffs, "test.gff"), self.example.gff_file) gen_file(os.path.join(self.trans, "test_transcript.gff"), self.example.tran_file) gen_file(os.path.join(self.tsss, "test_TSS.gff"), self.example.tss_file) gen_file(os.path.join(self.terms, "test_term.gff"), self.example.term_file) args = self.mock_args.mock() args.tsss = self.tsss args.gffs = self.gffs args.trans = self.trans args.terms = self.terms args.out_folder = self.out log = open(os.path.join(self.test_folder, "test.log"), "w") self.utr.run_utr_detection(args, log) self.assertTrue( os.path.exists(os.path.join(utr5_stat_path, "test_5utr_length.png"))) self.assertTrue( os.path.exists(os.path.join(utr3_stat_path, "test_3utr_length.png")))
class TestGensRNAOutput(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_merge_info(self): blasts = [{"strain": "aaa", "strand": "+", "start": 20, "end": 70, "hits": "111"}, {"strain": "aaa", "strand": "+", "start": 20, "end": 70, "hits": "222"}, {"strain": "aaa", "strand": "+", "start": 20, "end": 70, "hits": "333"}, {"strain": "aaa", "strand": "+", "start": 20, "end": 70, "hits": "444"}, {"strain": "bbb", "strand": "+", "start": 20, "end": 70, "hits": "555"}] merge = gso.merge_info(blasts) self.assertDictEqual(merge[0], {'hits': '111;222;333', 'start': 20, 'strand': '+', 'strain': 'aaa', 'end': 70}) self.assertDictEqual(merge[1], {'hits': '555', 'start': 20, 'strand': '+', 'strain': 'bbb', 'end': 70}) def test_compare_srna_table(self): final = {"energy": -23, "utr": "3UTR"} srna_dict = {"seq_id": "aaa", "source": "Refseq", "feature": "sRNA", "start": 300, "end": 367, "phase": ".", "strand": "+", "score": "."} attributes_srna = {"ID": "srna0", "Name": "sRNA_0"} srna = Create_generator(srna_dict, attributes_srna, "gff") args = self.mock_args.mock() args.min_len = 30 args.max_len = 500 new_final = gso.compare_srna_table(self.example.srna_tables, srna, final, args) self.assertDictEqual(new_final, {'end_pro': 'NA', 'strand': '+', 'strain': 'aaa', 'avg': 100, 'type': 'TEX+/-;Fragmented', 'conds': 'tex_frag', 'candidates': '300-367', 'tss_pro': 'TSS:300_+', 'start': 300, 'utr': '3UTR', 'energy': -23, 'end': 367}) def test_compare(self): args = self.mock_args.mock() args.min_len = 30 args.max_len = 500 finals = gso.compare(self.example.srnas, self.example.srna_tables, self.example.nr_blasts, self.example.srna_blasts, args) for index in range(len(finals)): self.assertDictEqual(finals[index], self.example.finals[index]) def test_gen_best_srna(self): gso.read_gff = Mock_func().mock_read_gff args = self.mock_args.mock() args.min_len = 30 args.max_len = 500 args.nr_hits_num = 0 args.energy = 0 args.import_info = ["term", "sec_str", "sorf"] out_file = os.path.join(self.test_folder, "test.out") gso.gen_best_srna("test.srna", out_file, args) with open(out_file) as fh: for line in fh: if not (line.startswith("#")): data = "\t".join(line.split("\t")[:-1]) self.assertEqual(data, "bbb\tintergenic\tsRNA\t18\t50\t.\t-\t.")
class TestsRNAIntergenic(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.mock = Mock_func() self.test_folder = "test_folder" self.wig_folder = "test_folder/wigs" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) os.mkdir(self.wig_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_read_data(self): gff_file = os.path.join(self.test_folder, "anno.gff") tran_file = os.path.join(self.test_folder, "tran.gff") pro_file = os.path.join(self.test_folder, "pro.gff") gen_file(gff_file, self.example.gff_file) gen_file(tran_file, self.example.gff_file) gen_file(pro_file, self.example.gff_file) args = self.mock_args.mock() args.gff_file = gff_file args.tran_file = tran_file args.pro_file = pro_file args.ex_srna = False nums, cdss, tas, pros, genes, ncs = si.read_data(args) self.assertDictEqual(nums, {'ta': 3, 'cds': 3, 'pro': 3, 'uni': 0}) self.assertEqual(cdss[0].start, 140) self.assertEqual(tas[0].start, 140) self.assertEqual(pros[0].start, 140) def test_read_tss(self): tss_file = os.path.join(self.test_folder, "tss.gff") gen_file(tss_file, self.example.gff_file) tsss, num_tss = si.read_tss(tss_file) self.assertEqual(tsss[0].start, 140) def test_compare_ta_cds(self): detects = {"overlap": False} gffs = copy.deepcopy(self.example.gffs) tas = copy.deepcopy(self.example.tas) si.compare_ta_cds(gffs, tas[0], detects) self.assertDictEqual(detects, {'overlap': True}) def test_compare_ta_tss(self): out_table = StringIO() nums = {'pro': 3, 'tss': 3, 'uni': 0, 'cds': 3, 'ta': 3} output = StringIO() detects = {"overlap": False, "uni_with_tss": False} si.get_coverage = self.mock.mock_get_coverage args = self.mock_args.mock() args.tex_notex = "tex_notex" args.min_len = 30 args.max_len = 300 args.decrease_inter = 50 args.fuzzy_inter = 5 args.tolerance = 5 args.tsss = copy.deepcopy(self.example.tsss) args.nums = nums args.fuzzy = 20 args.detects = detects args.texs = "texs" args.replicates = "rep" args.table_best = True args.wigs_f = "" args.wigs_r = "" args.output = output args.out_table = out_table tas = copy.deepcopy(self.example.tas) tsss = copy.deepcopy(self.example.tsss) si.compare_ta_tss(10, 2, 15, tas[0], tsss[0], 50, "cutoff", 20, "", args) self.assertEqual(output.getvalue(), ("aaa\tANNOgesic\tncRNA\t10\t15\t.\t+\t.\t" "ID=aaa_srna0;Name=sRNA_00000;sRNA_type=intergenic;" "with_TSS=TSS:170_+\n")) self.assertEqual(out_table.getvalue(), ("aaa\t00000\t10\t15\t+\tNA\tNA\t" "NA\tNA\tNA\tTSS:170_+\n")) si.get_coverage = get_coverage def test_print_file(self): string = "aaa\tintergenic\tsRNA\t10\t15\t.\t+\t." nums = {'pro': 3, 'tss': 3, 'uni': 0, 'cds': 3, 'ta': 3} out_table = StringIO() output = StringIO() srna_datas = { "high": 20, "low": 5, "best": 13, "conds": { "cond1": "test1" }, "detail": [{ "track": "test1", "high": 30, "low": 10, "avg": 15 }, { "track": "test2", "high": 25, "low": 13, "avg": 20 }] } args = self.mock_args.mock() args.nums = nums args.out_table = out_table args.output = output args.table_best = False si.print_file(string, "TSS_160+", srna_datas, "intergenic", args, "aaa") self.assertEqual(out_table.getvalue(), ("aaa\t00000\t10\t15\t+\tcond1\ttest1\t13\t20\t5\t" "TSS_160+\ttest1(avg=15;high=30;low=10);" "test2(avg=20;high=25;low=13)\n")) self.assertEqual(output.getvalue(), ("aaa\tintergenic\tsRNA\t10\t15\t.\t+\t.\t" "ID=aaa_srna0;Name=sRNA_00000;sRNA_type=intergenic;" "with_TSS=TSS_160+;best_avg_coverage=13;" "best_high_coverage=20;best_low_coverage=5\n")) def test_detect_include_tss(self): si.get_coverage = self.mock.mock_get_coverage nums = {'pro': 3, 'tss': 3, 'uni': 0, 'cds': 3, 'ta': 3} out_table = StringIO() output = StringIO() detects = {"overlap": False, "uni_with_tss": False} coverage = { "primary": 0, "secondary": 0, "internal": 0, "antisense": 50, "orphan": 10 } args = self.mock_args.mock() args.tex_notex = "tex_notex" args.min_len = 30 args.max_len = 300 args.decrease_inter = 50 args.fuzzy_inter = 5 args.tolerance = 5 args.tsss = copy.deepcopy(self.example.tsss) args.nums = nums args.fuzzy = 20 args.detects = detects args.cutoff_coverage = coverage args.texs = "texs" args.replicates = "rep" args.table_best = True args.wigs_f = "" args.wigs_r = "" args.notex = coverage args.file_type = "frag" args.break_tran = False args.output = output args.out_table = out_table tas = copy.deepcopy(self.example.tas) si.detect_include_tss(tas[0], args, None, args.wigs_f, args.wigs_r) si.get_coverage = get_coverage self.assertEqual(output.getvalue(), ("aaa\tANNOgesic\tncRNA\t170\t230\t.\t+\t.\t" "ID=aaa_srna0;Name=sRNA_00000;sRNA_type=intergenic;" "with_TSS=TSS:170_+\n")) self.assertEqual(out_table.getvalue(), ("aaa\t00000\t170\t230\t+\tNA\tNA\tNA" "\tNA\tNA\tTSS:170_+\n")) def test_get_differential_cover(self): checks = {"detect_diff": True, "first": True} cover_sets = {"diff": 30, "low": 5, "high": 35} cover = 20 poss = {"stop_point": 100} args = self.mock_args.mock() args.fuzzy_inter = 10 args.decrease_inter = 200 si.get_differential_cover(0, checks, cover_sets, poss, cover, args, 80) self.assertDictEqual(cover_sets, {'diff': 20, 'low': 20, 'high': 35}) cover = 50 poss = {"stop_point": 100} num = 20 args.fuzzy_inter = 20 si.get_differential_cover(num, checks, cover_sets, poss, cover, args, 80) self.assertDictEqual(poss, {"stop_point": 80}) def test_check_coverage_pos(self): si.coverage_comparison = self.mock.mock_coverage_comparison cover_sets = {"low": 20, "high": 30, "total": 90, "diff": 50} poss = {"high": 20, "low": 70, "stop_point": 70} tmps = {"total": 0, "toler": 10, "pos": 0} checks = {"detect_diff": True, "first": True} cover = {"coverage": 50, "pos": 80} detect = si.check_coverage_pos(30, 100, cover, 80, cover_sets, checks, poss, "+", 5) self.assertFalse(detect) self.assertDictEqual(poss, {'high': 20, 'stop_point': 70, 'low': 70}) def test_get_best(self): args = self.mock_args.mock() args.tolerance = 5 args.fuzzy_inter = 5 args.decrease_inter = 50 datas = si.get_best(self.example.wigs, "aaa", "+", 2, 20, "normal", args, 10) self.assertDictEqual( datas, { 'frag_1': [{ 'low': -1, 'high': -1, 'avg': 30.7, 'pos': 21, 'type': 'frag', 'track': 'track_1' }] }) def test_get_attribute_string(self): srna_datas = {'best': 23, 'low': 20, 'high': 35} data = si.get_attribute_string(srna_datas, "TSS_100+;Cleavage_150+", 1, "sRNA_00001", "3utr", "aaa") self.assertEqual(data, ("ID=aaa_srna1;Name=sRNA_sRNA_00001;sRNA_type=3utr;" "with_TSS=TSS_100+;end_cleavage=Cleavage_150+;" "best_avg_coverage=23;best_high_coverage=35;" "best_low_coverage=20")) def test_check_pro(self): si.replicate_comparison = self.mock.mock_replicate_comparison srna_datas = {"pos": 50} texs = {"track_1@AND@track_2"} args = self.mock_args.mock() args.tex_notex = "tex_notex" args.min_len = 30 args.max_len = 300 args.decrease_inter = 50 args.fuzzy_inter = 5 args.tolerance = 5 args.tex_notex = "tex_notex" args.replicates = "rep" args.texs = texs args.pros = copy.deepcopy(self.example.pros) tas = copy.deepcopy(self.example.tas) pro_pos, new_srna_datas, detect_pro = si.check_pro( tas[0], 20, 70, srna_datas, "within", 5, self.example.wigs, 20, args) self.assertEqual(pro_pos, 190) self.assertDictEqual( new_srna_datas, { 'best': 40, 'high': 50, 'low': 10, "pos": 5, "conds": { "cond1": "test1" }, "detail": None }) self.assertEqual(detect_pro, "Cleavage:190_+") def test_exchange_to_pro(self): nums = {'pro': 3, 'tss': 3, 'uni': 0, 'cds': 3, 'ta': 3} out_table = StringIO() output = StringIO() srna_datas = {"pos": 50, "best": 10, "high": 12} args = self.mock_args.mock() args.max_len = 300 args.min_len = 30 args.table_best = True args.replicates = "rep" args.tex_notex = "tex_notex" args.texs = "texs" args.decrease_inter = 50 args.fuzzy_inter = 5 args.pros = copy.deepcopy(self.example.pros) tas = copy.deepcopy(self.example.tas) args.tolerance = 5 si.replicate_comparison = self.mock.mock_replicate_comparison detect, srna_datas, pro = si.exchange_to_pro(args, srna_datas, tas[0], 20, 70, 10, self.example.wigs, 20) self.assertTrue(detect) self.assertDictEqual( srna_datas, { 'best': 40, 'high': 50, 'low': 10, 'pos': 190, "conds": { "cond1": "test1" }, "detail": None }) self.assertEqual(pro, "Cleavage:190_+") def test_get_tss_type(self): coverage = { "primary": 0, "secondary": 0, "internal": 0, "antisense": 50, "orphan": 10 } si.check_break_tran = self.mock.mock_check_break_tran cover = si.get_tss_type(self.example.tsss[0], coverage, None, None, None, False) self.assertEqual(cover, 10) def test_detect_wig_pos(self): si.replicate_comparison = self.mock.mock_replicate_comparison nums = {'pro': 3, 'tss': 3, 'uni': 0, 'cds': 3, 'ta': 3} out_table = StringIO() output = StringIO() args = self.mock_args.mock() args.texs = "texs" args.replicates = "rep" args.max_len = 300 args.min_len = 30 args.decrease_inter = 50 args.fuzzy_inter = 5 args.tex_notex = "tex_notex" args.pros = copy.deepcopy(self.example.pros) tas = copy.deepcopy(self.example.tas) args.table_best = True args.nums = nums args.out_table = out_table args.output = output args.tolerance = 5 si.detect_wig_pos(self.example.wigs, tas[0], 20, 70, "TSS_160+", 10, 20, args) self.assertEqual(output.getvalue(), ("aaa\tANNOgesic\tncRNA\t20\t190\t.\t+\t.\t" "ID=aaa_srna0;Name=sRNA_00000;sRNA_type=intergenic;" "with_TSS=TSS_160+;end_cleavage=Cleavage:190_+;" "best_avg_coverage=40;best_high_coverage=50;" "best_low_coverage=10\n")) self.assertEqual(out_table.getvalue(), ("aaa\t00000\t20\t190\t+\tcond1\t" "test1\t40\t50\t10\t\n")) def test_detect_longer(self): si.replicate_comparison = self.mock.mock_replicate_comparison si.coverage_comparison = self.mock.mock_coverage_comparison nums = {'pro': 3, 'tss': 3, 'uni': 0, 'cds': 3, 'ta': 3} out_table = StringIO() output = StringIO() detects = {"overlap": False, "uni_with_tss": False} coverage = { "primary": 0, "secondary": 0, "internal": 0, "antisense": 50, "orphan": 10 } args = self.mock_args.mock() args.tex_notex = "tex_notex" args.min_len = 30 args.max_len = 300 args.decrease_inter = 50 args.fuzzy_inter = 5 args.tolerance = 5 args.tsss = copy.deepcopy(self.example.tsss) args.pros = copy.deepcopy(self.example.pros) tas = copy.deepcopy(self.example.tas) args.nums = nums args.fuzzy = 20 args.file_type = "frag" args.break_tran = False args.detects = detects args.cutoff_coverage = coverage args.texs = "texs" args.replicates = "rep" args.table_best = True args.wigs_f = "" args.wigs_r = "" args.notex = 20 args.output = output args.out_table = out_table si.get_tss_type = self.mock.mock_get_tss_type si.detect_longer(tas[0], args, None, args.wigs_f, args.wigs_r) self.assertEqual(output.getvalue(), ("aaa\tANNOgesic\tncRNA\t170\t230\t.\t+\t.\t" "ID=aaa_srna0;Name=sRNA_00000;sRNA_type=intergenic;" "with_TSS=TSS:170_+\n")) self.assertEqual(out_table.getvalue(), ("aaa\t00000\t170\t230\t+\tNA\tNA\tNA" "\tNA\tNA\tTSS:170_+\n")) def test_get_proper_tss(self): tss_file = os.path.join(self.test_folder, "tss.gff") gen_file(tss_file, self.example.gff_file) coverage = { "primary": 0, "secondary": 0, "internal": 0, "antisense": 50, "orphan": 10 } tsss, num_tss = si.get_proper_tss(tss_file, coverage) self.assertEqual(tsss[0].start, 140) def test_check_srna_condition(self): si.replicate_comparison = self.mock.mock_replicate_comparison si.coverage_comparison = self.mock.mock_coverage_comparison nums = {'pro': 3, 'tss': 3, 'uni': 0, 'cds': 3, 'ta': 3} out_table = StringIO() output = StringIO() detects = {"overlap": False, "uni_with_tss": False} notex = { "primary": 0, "secondary": 0, "internal": 0, "antisense": 30, "orphan": 10 } coverage = { "primary": 0, "secondary": 0, "internal": 0, "antisense": 50, "orphan": 10 } args = self.mock_args.mock() args.tex_notex = "tex_notex" args.min_len = 30 args.max_len = 300 args.decrease_inter = 50 args.fuzzy_inter = 5 args.tolerance = 5 args.tsss = copy.deepcopy(self.example.tsss) args.pros = copy.deepcopy(self.example.pros) tas = copy.deepcopy(self.example.tas) args.nums = nums args.fuzzy = 20 args.detects = detects args.texs = "texs" args.replicates = "rep" args.table_best = True args.wigs_f = "" args.wigs_r = "" args.file_type = "frag" args.break_tran = False args.notex = notex args.output = output args.cutoff_coverage = coverage args.out_table = out_table si.check_srna_condition(tas[0], args, None, args.wigs_f, args.wigs_r) self.assertEqual(output.getvalue(), ("aaa\tANNOgesic\tncRNA\t170\t230\t.\t+\t.\t" "ID=aaa_srna0;Name=sRNA_00000;sRNA_type=intergenic;" "with_TSS=TSS:170_+\n")) self.assertEqual(out_table.getvalue(), ("aaa\t00000\t170\t230\t+\tNA\tNA\t" "NA\tNA\tNA\tTSS:170_+\n")) def test_intergenic_srna(self): si.read_libs = self.mock.mock_read_libs si.read_wig = self.mock.mock_read_wig gff_file = os.path.join(self.test_folder, "aaa.gff") tss_file = os.path.join(self.test_folder, "aaa_TSS.gff") tran_file = os.path.join(self.test_folder, "aaa_tran.gff") pro_file = os.path.join(self.test_folder, "aaa_processing.gff") wig_f_file = os.path.join(self.wig_folder, "wig_f.wig") wig_r_file = os.path.join(self.wig_folder, "wig_r.wig") gen_file(gff_file, self.example.gff_file) gen_file(tss_file, self.example.gff_file) gen_file(tran_file, self.example.gff_file) gen_file(pro_file, self.example.gff_file) output_file = os.path.join(self.test_folder, "output") output_table = os.path.join(self.test_folder, "table") coverage = [0, 0, 0, 50, 10] si.replicate_comparison = self.mock.mock_replicate_comparison si.coverage_comparison = self.mock.mock_coverage_comparison args = self.mock_args.mock() args.gff_file = gff_file args.tran_file = tran_file args.pro_file = pro_file args.tss_file = tss_file args.table_best = True args.cutoffs = coverage args.out_folder = self.test_folder args.file_type = "frag" args.cut_notex = coverage args.input_libs = "input_libs" args.wig_folder = self.wig_folder args.wig_f_file = wig_f_file args.wig_r_file = wig_r_file args.tss_source = True args.output_file = output_file args.output_table = output_table args.in_cds = False args.wigs_f = None args.wigs_r = None args.ex_srna = False si.intergenic_srna(args, args.input_libs, None, args.wigs_f, args.wigs_r) self.assertTrue(os.path.exists(output_file)) self.assertTrue(os.path.exists(output_table))
class TestGetPolyT(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_filter_term(self): cands = [ { "r_stem": 6, "l_stem": 6, "miss": 2, "print": False, "strain": "aaa", "end": 500, "start": 30 }, { "r_stem": 6, "l_stem": 6, "miss": 0, "print": False, "strain": "aaa", "end": 400, "start": 50 }, { "r_stem": 3, "l_stem": 3, "miss": 2, "print": False, "strain": "aaa", "end": 50, "start": 10 }, { "r_stem": 6, "l_stem": 6, "miss": 0, "print": False, "strain": "bbb", "end": 450, "start": 60 }, ] terms = [] gpt.filter_term(cands, terms, 0.25) self.assertDictEqual( terms[0], { 'end': 500, 'l_stem': 6, 'miss': 0, 'print': False, 'strain': 'aaa', 'r_stem': 6, 'start': 30 }) self.assertDictEqual( terms[1], { 'end': 450, 'l_stem': 6, 'miss': 0, 'print': False, 'strain': 'bbb', 'r_stem': 6, 'start': 60 }) def test_check_sec(self): sec = "...((((((((..))))))..))...." features, detect = gpt.check_sec(sec, 26) self.assertDictEqual( features, { 'rights': 8, 'loop': 2, 'real_miss': 2, 'lefts': 8, 'l_stem': 0, 'st_pos': 23, 'r_stem': 10, 'tmp_miss': 2 }) self.assertDictEqual(detect, { 'detect_l': True, 'conflict': False, 'detect_r': True }) sec = "........))))))..))...." features, detect = gpt.check_sec(sec, 21) self.assertDictEqual( features, { 'r_stem': 0, 'loop': 0, 'lefts': 0, 'l_stem': 0, 'st_pos': 21, 'tmp_miss': 10, 'rights': 8, 'real_miss': 2 }) self.assertDictEqual(detect, { 'detect_r': True, 'conflict': False, 'detect_l': False }) def test_detect_candidates(self): seq = "GATCGGCAGTATTAAACGTACTTTTTTTTTT" sec = "...((((((((....))))))..))......" args = self.mock_args.mock() args.max_loop = 10 args.min_loop = 3 args.max_stem = 20 args.min_stem = 4 args.miss_rate = 0.25 args.at_tail = 3 args.range_u = 6 cands = gpt.detect_candidates(seq, sec, "test", "aaa", 30, 58, "gene_0", "gene_1", "+", args, "10-24", "70-100") refs = [{ 'strain': 'aaa', 'print': False, 'l_stem': 4, 'parent_m': 'gene_1', 'parent_p': 'gene_0', 'detect_m': False, 'ut': 4, 'start': 27, 'length': 12, 'loop': 4, 'end': 58, 'miss': 0, 'r_stem': 4, 'name': 'test', 'detect_p': False, 'strand': '+', "p_pos": "10-24", "m_pos": "70-100" }, { 'strain': 'aaa', 'print': False, 'l_stem': 5, 'parent_m': 'gene_1', 'parent_p': 'gene_0', 'detect_m': False, 'ut': 5, 'start': 26, 'length': 14, 'loop': 4, 'end': 59, 'miss': 0, 'r_stem': 5, 'name': 'test', 'detect_p': False, 'strand': '+', "p_pos": "10-24", "m_pos": "70-100" }, { 'strain': 'aaa', 'print': False, 'l_stem': 6, 'parent_m': 'gene_1', 'parent_p': 'gene_0', 'detect_m': False, 'ut': 6, 'start': 25, 'length': 16, 'loop': 4, 'end': 60, 'miss': 0, 'r_stem': 6, 'name': 'test', 'detect_p': False, 'strand': '+', "p_pos": "10-24", "m_pos": "70-100" }, { 'strain': 'aaa', 'print': False, 'l_stem': 7, 'parent_m': 'gene_1', 'parent_p': 'gene_0', 'detect_m': False, 'ut': 6, 'start': 24, 'length': 20, 'loop': 4, 'end': 63, 'miss': 2, 'r_stem': 9, 'name': 'test', 'detect_p': False, 'strand': '+', "p_pos": "10-24", "m_pos": "70-100" }] for index in range(len(cands)): self.assertDictEqual(cands[index], refs[index]) def test_check_parent(self): term = {"strain": "aaa", "start": 11, "end": 14} detects = {"parent_p": False, "parent_m": False} parent = gpt.check_parent(self.example.cdss, term, detects, "+", 3, 3, "parent_p") self.assertEqual(parent, "gene_0") parent = gpt.check_parent(self.example.cdss, term, detects, "-", 3, 3, "parent_m") self.assertEqual(parent, "gene_1") def test_parents(self): terms = [{ "strain": "aaa", "start": 11, "end": 14, "parent_p": "gene_0", "parent_m": "gene_1", "p_pos": "3-5", "m_pos": "20-50" }, { "strain": "aaa", "start": 12, "end": 15, "parent_p": "tran0:1-11_+", "parent_m": "tran1:16-30_-", "p_pos": "1-11", "m_pos": "16-30" }] args = self.mock_args.mock() args.fuzzy_up_gene = 10 args.fuzzy_up_ta = 10 args.fuzzy_down_gene = 10 args.fuzzy_down_ta = 10 gpt.parents(terms, self.example.cdss, args) self.assertDictEqual( terms[0], { 'parent_p': 'gene_0', 'parent_m': 'gene_1', 'start': 11, 'strain': 'aaa', 'end': 14, "p_pos": "3-5", "m_pos": "20-50" }) self.assertDictEqual( terms[1], { 'parent_p': 'tran0:1-11_+,gene_0', 'parent_m': 'tran1:16-30_-,gene_1', 'start': 12, 'strain': 'aaa', 'end': 15, "p_pos": "1-11", "m_pos": "16-30" }) def test_compare_anno(self): terms = [{ "strain": "aaa", "start": 11, "end": 14, "strand": "+" }, { "strain": "aaa", "start": 9, "end": 18, "strand": "-" }, { "strain": "aaa", "start": 209, "end": 218, "strand": "-" }] cands = gpt.compare_anno(self.example.cdss, terms, 3, 3) self.assertDictEqual(terms[0], { 'strand': '+', 'start': 11, 'strain': 'aaa', 'end': 14 }) self.assertDictEqual(terms[1], { "strain": "aaa", "start": 9, "end": 18, "strand": "-" })
class TestTranscriptAssembly(unittest.TestCase): def setUp(self): self.example = Example() self.mock_args = MockClass() self.test_folder = "test_folder" if (not os.path.exists(self.test_folder)): os.mkdir(self.test_folder) def tearDown(self): if os.path.exists(self.test_folder): shutil.rmtree(self.test_folder) def test_read_wig(self): libs = [{ "name": "test1", "type": "frag", "cond": "frag_1", "strand": "+", "rep": "a" }] filename = os.path.join(self.test_folder, "test_f.wig") gen_file(filename, self.example.wig_f) wigs = ta.read_wig(filename, "+", libs) for i in range(len(wigs["aaa"]['frag_1']["test1|+|frag"])): self.assertEqual( wigs["aaa"]['frag_1']["test1|+|frag"][i], self.example.wigs_nf["aaa"]['frag_1']["test1|+|frag"][i]) def test_detect_hight_toler(self): cover = 100 height = 5 tmp_covers = {"best": 10, "toler": 2} tracks = [] ta.detect_hight_toler(cover, height, tmp_covers, tracks, "test_1|+|frag") self.assertDictEqual(tmp_covers, {'best': 100, 'toler': 2}) def test_check_tex_conds(self): check_tex = [] tracks = ["test1", "test2"] libs = [{ "name": "test1", "type": "frag", "cond": "1", "strand": "+", "rep": "a" }, { "name": "test2", "type": "tex", "cond": "2", "strand": "+", "rep": "a" }] texs = {"test1": 2, "test2": 2} conds = {} ta.check_tex_conds(tracks, libs, texs, check_tex, conds, 1) self.assertDictEqual(conds, {'1': 1, '2': 1}) def test_elongation(self): covers = { "texnotex_1": { "test1|+|texnotex_1": [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20], "test2|+|texnotex_1": [0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 100] } } libs = [{ "name": "test1", "type": "tex", "cond": "texnotex_1", "strand": "+", "rep": "a" }, { "name": "test2", "type": "notex", "cond": "texnotex_1", "strand": "+", "rep": "a" }] reps = {"tex": "all_1", "frag": "all_1"} tmp_texs = {"test1_test2": 2} tolers = [] trans = {"aaa": []} args = self.mock_args.mock() args.replicates = reps args.height = 5 args.tex = 2 ta.elongation(covers, tmp_texs, libs, "+", trans, args, "aaa", []) self.assertDictEqual( trans, {'aaa': [-1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 100]}) def test_transfer_to_tran(self): reps = {"tex": "all_1", "frag": "all_1"} tmp_texs = {"test1": 2} libs = [{ "name": "test1", "type": "frag", "cond": "frag_1", "strand": "+", "rep": "a" }] args = self.mock_args.mock() args.height = 10 args.tex = 1 args.replicates = reps tolers, trans = ta.transfer_to_tran(self.example.wigs_f, libs, tmp_texs, "+", args) self.assertDictEqual(tolers, {'aaa': [0.0, 2.0, 20, 20, 4.0, 20, 7.0, 20]}) self.assertDictEqual(trans, {'aaa': [-1, -1, 41.0, 47.0, -1, 47.0, -1, 47.0]}) def test_fill_gap_and_print(self): trans = {'aaa': [-1, -1, 41.0, 47.0, -1, 47.0, -1, 47.0]} out = StringIO() tolers = {'aaa': [0.0, 2.0, 20, 20, 4.0, 20, 7, 7, 7, 7, 7, 7, 7, 20]} args = self.mock_args.mock() args.tolerance = 3 args.low_cutoff = 5 args.width = 1 ta.fill_gap_and_print(trans, "+", out, tolers, "TEX", args) self.assertEqual(out.getvalue(), self.example.out_tran + "\n") def test_print_transctipt(self): out = StringIO() ta.print_transctipt(100, 200, 20, 1, 40, "TEX", 20, out, "aaa", "+") self.assertEqual( out.getvalue(), "aaa\tANNOgesic\ttranscript\t100\t200\t.\t+\t.\tID=tran_1;Name=transcript_00001;high_coverage=40;low_coverage=20;detect_lib=TEX\n" ) def test_assembly(self): wig_f_file = os.path.join(self.test_folder, "aaa_forward.wig") wig_r_file = os.path.join(self.test_folder, "aaa_reverse.wig") wig_f2_file = os.path.join(self.test_folder, "aaa2_forward.wig") wig_r2_file = os.path.join(self.test_folder, "aaa2_reverse.wig") gen_file(wig_f_file, self.example.wig_f) gen_file(wig_r_file, self.example.wig_r) gen_file(wig_f2_file, self.example.wig_f) gen_file(wig_r2_file, self.example.wig_r) reps = {"tex": "all_1", "frag": "all_1"} out_file = os.path.join(self.test_folder, "out") input_lib = [ "aaa_forward.wig:frag:1:a:+", "aaa_reverse.wig:frag:1:a:-", "aaa2_forward.wig:tex:1:a:+", "aaa2_reverse.wig:tex:1:a:-" ] args = self.mock_args.mock() args.replicates = reps args.height = 10 args.width = 1 args.tolerance = 3 args.tex = 2 args.low_cutoff = 5 ta.assembly(wig_f_file, wig_r_file, self.test_folder, input_lib, out_file, "TEX", args) datas = import_data(out_file) self.assertEqual("\n".join(datas), "##gff-version 3\n" + self.example.out_tran)