source: orange-bioinformatics/tests/test_kegg.py @ 1548:80b9e523116b

Revision 1548:80b9e523116b, 4.7 KB checked in by ales_erjavec, 2 years ago (diff)

Fixed and added some tests for obiKEGG2

Line 
1import unittest
2import obiKEGG2 as kegg
3
4#from obiKEGGservices import
5#from
6
7#class TestServices(unittest.TestCase):
8#    def test_services(self):
9#        service = kegg.service.web_service()
10#        service.binfo("gb")
11#        service.bfind("gb E-cadherin human")
12#        service.bget("eco:b0002 hin:tRNA-Cys-1")
13       
14class TestGenome(unittest.TestCase):
15    def test_genome(self):
16        genome = kegg.KEGGGenome()
17        org_codes = genome.keys()
18       
19        for code in org_codes[:10]:
20            self.assertTrue(code in genome)
21            self.assertTrue(genome.has_key(code))
22            entry = genome[code]
23            self.assertEqual(entry.entry_key, code)
24            self.assertIsInstance(entry, genome.ENTRY_TYPE)
25            self.assertIsInstance(entry.name, str)
26            self.assertIsInstance(entry.taxid, str)
27           
28           
29        self.assertTrue(genome.get_entry("No such name --,,;;';p[[]&&&") is None)
30        self.assertRaises(KeyError, genome.__getitem__, ("No such name --,,;;';p[[]&&&"))
31       
32        self.assertTrue(genome.search("homo sapiens")[0] == "hsa")
33        entry = genome['hsa']
34        self.assertEqual(entry.taxid, "9606")
35       
36       
37class TestGenes(unittest.TestCase):
38    def _tester(self, org):
39        genes = kegg.KEGGGenes(org)
40        keys = genes.keys()[:10]
41        all_entries = []
42        for gene in keys:
43            self.assertTrue(gene in genes)
44            self.assertTrue(genes.has_key(gene))
45            entry = genes[gene]
46            self.assertEqual(entry.entry_key,
47                             genes.get(gene).entry_key,
48                             "__getitem__ and get return different result")
49            self.assertTrue(gene.endswith(entry.entry_key))
50            self.assertIsInstance(entry, genes.ENTRY_TYPE)
51            self.assertIsInstance(entry.aliases(), list)
52            self.assertTrue(all(isinstance(a, basestring) for a in entry.aliases()))
53            all_entries.append(entry)
54           
55        self.assertSequenceEqual([(e.name, e.entry_key) for e in all_entries],
56                                 [(e.name, e.entry_key) for e in genes.batch_get(keys)],
57                                 "batch_get returns different result")
58           
59    def test_hsa(self):
60        self._tester("hsa")
61       
62    def test_sce(self):
63        self._tester("sce")
64       
65    def test_ddi(self):
66        self._tester("ddi")
67   
68class TestPathways(unittest.TestCase):
69    def _tester(self, id):
70        pathways = kegg.KEGGPathways()
71       
72        self.assertRaises(KeyError, pathways.__getitem__, ("--invalid--"))
73        pathway = pathways[id]
74        self.assertTrue(id.endswith(pathway.entry_key))
75        self.assertIsInstance(pathway, pathways.ENTRY_TYPE)
76        genes = pathway.gene or []
77       
78        path = kegg.KEGGPathway(id)
79        self.assertEqual(sorted(genes), sorted(path.genes()))
80       
81       
82    def test_1(self):
83        self._tester("ec00190")
84           
85    def test_2(self):
86        self._tester("hsa00190")
87       
88    def test_3(self):
89        self._tester("sce00190")
90       
91       
92class TestOrganism(unittest.TestCase):
93    def _tester(self, org):
94        self.organism = org = kegg.KEGGOrganism(org)
95        genes = org.genes
96        self.assertTrue(all(g.startswith(org.org_code) for g in genes))
97        pathways = org.pathways()
98        pathways_for_genes = org.pathways(with_ids=list(genes)[:5])
99        self.assertTrue(all(p.startswith("path:" + org.org_code) \
100                            for p in pathways + pathways_for_genes))
101       
102    def test_hsa(self):
103        self._tester("hsa")
104        # Test search
105        self.assertEqual(self.organism.org_code,
106                         kegg.KEGGOrganism("Homo sapiens").org_code)
107       
108    def test_sce(self):
109        self._tester("sce")
110       
111       
112class TestUtils(unittest.TestCase):
113    def test_batch_iter(self):
114        iter = range(25)
115        expected = [range(10),
116                     range(10, 20),
117                     range(20, 25)]
118        for exp, batch in zip(expected, 
119                              kegg.databases.batch_iter(iter, 10)
120                              ):
121            self.assertEqual(exp, batch)
122   
123   
124class TestOld(unittest.TestCase):
125    def test(self):
126        p = kegg.KEGGPathway("sce00010")
127        print p.genes
128        print p.reactions
129        print p.compounds
130        print p.image
131        g = kegg.KEGGGenome()
132        org = kegg.KEGGOrganism("Homo sapiens")
133        print list(org.genes)[:10]
134#        org.gene_aliases
135        print org.pathways(with_ids=org.genes.keys()[:5])
136#        print org.enzymes()
137        print org.get_enriched_pathways(org.genes.keys()[:10])
138        print org.genematcher
Note: See TracBrowser for help on using the repository browser.