Changeset 1744:fad34df9e962 in orange-bioinformatics


Ignore:
Timestamp:
04/12/13 13:14:07 (12 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Moved old obiKEGG tests inside the obiKEGG package.

Files:
1 deleted
1 moved

Legend:

Unmodified
Added
Removed
  • _bioinformatics/obiKEGG/tests/test_databases.py

    r1632 r1744  
    11import unittest 
    22 
    3 from Orange.bioinformatics import obiKEGG2 as kegg 
     3from .. import databases 
     4from .. import pathway 
    45 
    5 #from obiKEGGservices import  
    6 #from  
    76 
    8 #class TestServices(unittest.TestCase): 
    9 #    def test_services(self): 
    10 #        service = kegg.service.web_service() 
    11 #        service.binfo("gb") 
    12 #        service.bfind("gb E-cadherin human") 
    13 #        service.bget("eco:b0002 hin:tRNA-Cys-1") 
    14          
    157class TestGenome(unittest.TestCase): 
    168    def test_genome(self): 
    17         genome = kegg.KEGGGenome() 
    18         org_codes = genome.keys() 
    19          
    20         for code in org_codes[:10]: 
    21             self.assertTrue(code in genome) 
    22             self.assertTrue(genome.has_key(code)) 
    23             entry = genome[code] 
    24             self.assertEqual(entry.entry_key, code) 
     9        genome = databases.Genome() 
     10        entry_keys = genome.keys() 
     11 
     12        for key in entry_keys[:3] + entry_keys[-3:]: 
     13            self.assertTrue(key in genome) 
     14            self.assertTrue(key in genome) 
     15            entry = genome[key] 
     16            self.assertEqual(entry.entry_key, key) 
    2517            self.assertIsInstance(entry, genome.ENTRY_TYPE) 
     18            # Should we allow fields to be unicode? 
    2619            self.assertIsInstance(entry.name, str) 
    2720            self.assertIsInstance(entry.taxid, str) 
    28              
    29              
    30         self.assertTrue(genome.get_entry("No such name --,,;;';p[[]&&&") is None) 
    31         self.assertRaises(KeyError, genome.__getitem__, ("No such name --,,;;';p[[]&&&")) 
    32          
     21 
    3322        self.assertTrue(genome.search("homo sapiens")[0] == "hsa") 
    3423        entry = genome['hsa'] 
    3524        self.assertEqual(entry.taxid, "9606") 
    36          
    37          
     25 
     26 
    3827class TestGenes(unittest.TestCase): 
    3928    def _tester(self, org): 
    40         genes = kegg.KEGGGenes(org) 
    41         keys = genes.keys()[:10] 
     29        genes = databases.Genes(org) 
     30        keys = genes.keys()[:3] + genes.keys()[-3:] 
    4231        all_entries = [] 
    4332        for gene in keys: 
    4433            self.assertTrue(gene in genes) 
    45             self.assertTrue(genes.has_key(gene)) 
    4634            entry = genes[gene] 
    4735            self.assertEqual(entry.entry_key, 
    4836                             genes.get(gene).entry_key, 
    4937                             "__getitem__ and get return different result") 
     38 
    5039            self.assertTrue(gene.endswith(entry.entry_key)) 
     40 
    5141            self.assertIsInstance(entry, genes.ENTRY_TYPE) 
    5242            self.assertIsInstance(entry.aliases(), list) 
    53             self.assertTrue(all(isinstance(a, basestring) for a in entry.aliases())) 
     43 
     44            self.assertTrue(all(isinstance(a, basestring) 
     45                                for a in entry.aliases())) 
    5446            all_entries.append(entry) 
    55              
    56         self.assertSequenceEqual([(e.name, e.entry_key) for e in all_entries], 
    57                                  [(e.name, e.entry_key) for e in genes.batch_get(keys)], 
    58                                  "batch_get returns different result") 
    59              
     47 
     48        self.assertSequenceEqual( 
     49            [(e.name, e.entry_key) for e in all_entries], 
     50            [(e.name, e.entry_key) for e in genes.batch_get(keys)], 
     51            "batch_get returns different result") 
     52 
    6053    def test_hsa(self): 
    6154        self._tester("hsa") 
    62          
     55 
    6356    def test_sce(self): 
    6457        self._tester("sce") 
    65          
     58 
    6659    def test_ddi(self): 
    6760        self._tester("ddi") 
    68      
     61 
     62 
    6963class TestPathways(unittest.TestCase): 
    70     def _tester(self, id): 
    71         pathways = kegg.KEGGPathways() 
    72          
    73         self.assertRaises(KeyError, pathways.__getitem__, ("--invalid--")) 
    74         pathway = pathways[id] 
    75         self.assertTrue(id.endswith(pathway.entry_key)) 
    76         self.assertIsInstance(pathway, pathways.ENTRY_TYPE) 
    77         genes = pathway.gene or [] 
    78          
    79         path = kegg.KEGGPathway(id) 
     64    def _tester(self, path_id): 
     65        pathways = databases.Pathway() 
     66 
     67        entry = pathways[path_id] 
     68        self.assertTrue(path_id.endswith(entry.entry_key)) 
     69        self.assertIsInstance(entry, pathways.ENTRY_TYPE) 
     70 
     71        genes = entry.gene or [] 
     72 
     73        path = pathway.Pathway(path_id) 
    8074        self.assertEqual(sorted(genes), sorted(path.genes())) 
    81          
    82          
    83     def test_1(self): 
    84         self._tester("ec00190") 
    85              
    86     def test_2(self): 
    87         self._tester("hsa00190") 
    88          
    89     def test_3(self): 
    90         self._tester("sce00190") 
    91          
    92          
    93 class TestOrganism(unittest.TestCase): 
    94     def _tester(self, org): 
    95         self.organism = org = kegg.KEGGOrganism(org) 
    96         genes = org.genes 
    97         self.assertTrue(all(g.startswith(org.org_code) for g in genes)) 
    98         pathways = org.pathways() 
    99         pathways_for_genes = org.pathways(with_ids=list(genes)[:5]) 
    100         self.assertTrue(all(p.startswith("path:" + org.org_code) \ 
    101                             for p in pathways + pathways_for_genes)) 
    102          
    103     def test_hsa(self): 
    104         self._tester("hsa") 
    105         # Test search 
    106         self.assertEqual(self.organism.org_code, 
    107                          kegg.KEGGOrganism("Homo sapiens").org_code) 
    108          
    109     def test_sce(self): 
    110         self._tester("sce") 
    111          
    112          
     75 
     76    def test(self): 
     77        self._tester("path:map00627") 
     78 
     79 
    11380class TestUtils(unittest.TestCase): 
    11481    def test_batch_iter(self): 
    11582        iter = range(25) 
    11683        expected = [range(10), 
    117                      range(10, 20), 
    118                      range(20, 25)] 
    119         for exp, batch in zip(expected,  
    120                               kegg.databases.batch_iter(iter, 10) 
    121                               ): 
     84                    range(10, 20), 
     85                    range(20, 25)] 
     86        for exp, batch in zip(expected, 
     87                              databases.batch_iter(iter, 10)): 
    12288            self.assertEqual(exp, batch) 
    123      
    124      
    125 class TestOld(unittest.TestCase): 
    126     def test(self): 
    127         p = kegg.KEGGPathway("sce00010") 
    128         print p.genes 
    129         print p.reactions 
    130         print p.compounds 
    131         print p.image 
    132         g = kegg.KEGGGenome() 
    133         org = kegg.KEGGOrganism("Homo sapiens") 
    134         print list(org.genes)[:10] 
    135 #        org.gene_aliases 
    136         print org.pathways(with_ids=org.genes.keys()[:5]) 
    137 #        print org.enzymes() 
    138         print org.get_enriched_pathways(org.genes.keys()[:10]) 
    139         print org.genematcher 
Note: See TracChangeset for help on using the changeset viewer.