Merge pull request #2004 from jamesmkrieger/less_tests

Less tests

.github/workflows/main.yml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["2.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["2.7", "3.9", "3.10", "3.11", "3.12"]
 
     steps:
     - uses: actions/checkout@v2

prody/tests/database/test_pfam.py

@@ -1,227 +1,227 @@
-"""This module contains unit tests for :mod:`prody.database.pfam` module."""
+# """This module contains unit tests for :mod:`prody.database.pfam` module."""
 
-from prody.tests import unittest
-from prody.database.pfam import searchPfam
-from prody.database.pfam import fetchPfamMSA
-from prody.database.pfam import parsePfamPDBs
+# from prody.tests import unittest
+# from prody.database.pfam import searchPfam
+# from prody.database.pfam import fetchPfamMSA
+# from prody.database.pfam import parsePfamPDBs
 
-from prody.atomic.selection import Selection
+# from prody.atomic.selection import Selection
 
-import os
-import shutil
+# import os
+# import shutil
 
-from prody import LOGGER
-LOGGER.verbosity = 'none'
+# from prody import LOGGER
+# LOGGER.verbosity = 'none'
 
-class TestSearchPfam(unittest.TestCase):
+# class TestSearchPfam(unittest.TestCase):
 
-    @classmethod
-    def setUpClass(self):
-        self.workdir = 'pfam_search_tests'
-        if not os.path.exists(self.workdir):
-            os.mkdir(self.workdir)
-        os.chdir(self.workdir)
+#     @classmethod
+#     def setUpClass(self):
+#         self.workdir = 'pfam_search_tests'
+#         if not os.path.exists(self.workdir):
+#             os.mkdir(self.workdir)
+#         os.chdir(self.workdir)
 
-        self.queries = ['P19491', '6qkcB', '6qkcI']
+#         self.queries = ['P19491', '6qkcB', '6qkcI']
 
-    def testUniprotAccMulti(self):
-        """Test the outcome of a simple search scenario using a Uniprot Accession 
-        for a multi-domain protein, AMPAR GluA2."""
+#     def testUniprotAccMulti(self):
+#         """Test the outcome of a simple search scenario using a Uniprot Accession 
+#         for a multi-domain protein, AMPAR GluA2."""
 
-        a = searchPfam(self.queries[0])
+#         a = searchPfam(self.queries[0])
 
-        self.assertIsInstance(a, dict,
-            'searchPfam failed to return a dict instance')
+#         self.assertIsInstance(a, dict,
+#             'searchPfam failed to return a dict instance')
 
-        self.assertEqual(sorted(list(a.keys())), 
-                         ['PF00060', 'PF01094', 'PF10613'],
-                         'searchPfam failed to return the right domain family IDs')
+#         self.assertEqual(sorted(list(a.keys())), 
+#                          ['PF00060', 'PF01094', 'PF10613'],
+#                          'searchPfam failed to return the right domain family IDs')
 
-    def testPdbIdChMulti(self):
-        """Test the outcome of a simple search scenario using a PDB ID
-        and chain ID for the same multi-domain protein from specifying chain B."""
+#     def testPdbIdChMulti(self):
+#         """Test the outcome of a simple search scenario using a PDB ID
+#         and chain ID for the same multi-domain protein from specifying chain B."""
 
-        a = searchPfam(self.queries[1])
+#         a = searchPfam(self.queries[1])
 
-        self.assertIsInstance(a, dict,
-            'searchPfam failed to return a dict instance')
+#         self.assertIsInstance(a, dict,
+#             'searchPfam failed to return a dict instance')
 
-        self.assertEqual(sorted(list(a.keys())), ['PF00060', 'PF01094', 'PF10613'],
-                         'searchPfam failed to return the right domain family IDs for AMPAR')
+#         self.assertEqual(sorted(list(a.keys())), ['PF00060', 'PF01094', 'PF10613'],
+#                          'searchPfam failed to return the right domain family IDs for AMPAR')
 
-    def testPdbIdChSingle(self):
-        """Test the outcome of a simple search scenario using a PDB ID
-        and chain ID to get the single domain protein TARP g8 from chain I."""
+#     def testPdbIdChSingle(self):
+#         """Test the outcome of a simple search scenario using a PDB ID
+#         and chain ID to get the single domain protein TARP g8 from chain I."""
 
-        a = searchPfam(self.queries[2])
+#         a = searchPfam(self.queries[2])
 
-        self.assertIsInstance(a, dict,
-            'searchPfam failed to return a dict instance')
+#         self.assertIsInstance(a, dict,
+#             'searchPfam failed to return a dict instance')
 
-        self.assertEqual(sorted(list(a.keys())), 
-                         ['PF00822', 'PF13903'],
-                         'searchPfam failed to return the right domain family IDs for TARP')
+#         self.assertEqual(sorted(list(a.keys())), 
+#                          ['PF00822', 'PF13903'],
+#                          'searchPfam failed to return the right domain family IDs for TARP')
 
-    @classmethod
-    def tearDownClass(self):
-        os.chdir('..')
-        shutil.rmtree(self.workdir)
+#     @classmethod
+#     def tearDownClass(self):
+#         os.chdir('..')
+#         shutil.rmtree(self.workdir)
 
 
-class TestFetchPfamMSA(unittest.TestCase):
+# class TestFetchPfamMSA(unittest.TestCase):
 
-    @classmethod
-    def setUpClass(self):
-        self.query = 'PF00822'
+#     @classmethod
+#     def setUpClass(self):
+#         self.query = 'PF00822'
 
-        self.workdir = 'pfam_msa_tests'
-        if not os.path.exists(self.workdir):
-            os.mkdir(self.workdir)
-        os.chdir(self.workdir)
+#         self.workdir = 'pfam_msa_tests'
+#         if not os.path.exists(self.workdir):
+#             os.mkdir(self.workdir)
+#         os.chdir(self.workdir)
 
-    def testDefault(self):
-        """Test the outcome of fetching the domain MSA for claudins
-        with default parameters."""
+#     def testDefault(self):
+#         """Test the outcome of fetching the domain MSA for claudins
+#         with default parameters."""
 
-        b = fetchPfamMSA(self.query)
+#         b = fetchPfamMSA(self.query)
 
-        self.assertIsInstance(b, str,
-            'fetchPfamMSA failed to return a str instance')
+#         self.assertIsInstance(b, str,
+#             'fetchPfamMSA failed to return a str instance')
 
-        self.assertEqual(b, 'PF00822_seed.sth')
+#         self.assertEqual(b, 'PF00822_seed.sth')
 
-        self.assertTrue(os.path.exists(b))
+#         self.assertTrue(os.path.exists(b))
 
 
-    def testSeed(self):
-        """Test the outcome of fetching the domain MSA for claudins
-        with the alignment type argument set to seed"""
+#     def testSeed(self):
+#         """Test the outcome of fetching the domain MSA for claudins
+#         with the alignment type argument set to seed"""
 
-        b = fetchPfamMSA(self.query, "seed")
+#         b = fetchPfamMSA(self.query, "seed")
 
-        self.assertIsInstance(b, str,
-            'fetchPfamMSA failed to return a str instance')
+#         self.assertIsInstance(b, str,
+#             'fetchPfamMSA failed to return a str instance')
 
-        self.assertEqual(b, 'PF00822_seed.sth')
+#         self.assertEqual(b, 'PF00822_seed.sth')
 
-        self.assertTrue(os.path.exists(b))
+#         self.assertTrue(os.path.exists(b))
 
-    def testFolder(self):
-        """Test the outcome of fetching the domain MSA for claudins
-        with keyword folder set to a folder that is made especially."""
+#     def testFolder(self):
+#         """Test the outcome of fetching the domain MSA for claudins
+#         with keyword folder set to a folder that is made especially."""
 
-        folder = "new_folder"
-        os.mkdir(folder)
-        b = fetchPfamMSA(self.query, folder=folder)
+#         folder = "new_folder"
+#         os.mkdir(folder)
+#         b = fetchPfamMSA(self.query, folder=folder)
 
-        self.assertIsInstance(b, str,
-            'fetchPfamMSA failed to return a str instance')
+#         self.assertIsInstance(b, str,
+#             'fetchPfamMSA failed to return a str instance')
 
-        self.assertEqual(b, 'new_folder/PF00822_seed.sth')
+#         self.assertEqual(b, 'new_folder/PF00822_seed.sth')
 
-        self.assertTrue(os.path.exists(b))
+#         self.assertTrue(os.path.exists(b))
 
-    @classmethod
-    def tearDownClass(self):
-        os.chdir('..')
-        shutil.rmtree(self.workdir)
+#     @classmethod
+#     def tearDownClass(self):
+#         os.chdir('..')
+#         shutil.rmtree(self.workdir)
 
 
-class TestParsePfamPDBs(unittest.TestCase):
+# class TestParsePfamPDBs(unittest.TestCase):
 
-    @classmethod
-    def setUpClass(self):
-        self.queries = ['PF20446', 'Q57ZF2', 'P40682']
+#     @classmethod
+#     def setUpClass(self):
+#         self.queries = ['PF20446', 'Q57ZF2', 'P40682']
 
-        self.workdir = 'pfam_pdb_tests'
-        if not os.path.exists(self.workdir):
-            os.mkdir(self.workdir)
-        os.chdir(self.workdir)
+#         self.workdir = 'pfam_pdb_tests'
+#         if not os.path.exists(self.workdir):
+#             os.mkdir(self.workdir)
+#         os.chdir(self.workdir)
 
-    def testPfamIdDefault(self):
-        """Test the outcome of parsing PDBs for a tiny family 
-        of ABC class ATPase N-terminal domains (5 members) 
-        with the Pfam ID and default parameters."""
+#     def testPfamIdDefault(self):
+#         """Test the outcome of parsing PDBs for a tiny family 
+#         of ABC class ATPase N-terminal domains (5 members) 
+#         with the Pfam ID and default parameters."""
 
-        b = parsePfamPDBs(self.queries[0])
+#         b = parsePfamPDBs(self.queries[0])
 
-        self.assertIsInstance(b, list,
-            'parsePfamPDBs failed to return a list instance')
+#         self.assertIsInstance(b, list,
+#             'parsePfamPDBs failed to return a list instance')
 
-        self.assertIsInstance(b[0], Selection,
-            'parsePfamPDBs failed to return a list of Selection instances')
+#         self.assertIsInstance(b[0], Selection,
+#             'parsePfamPDBs failed to return a list of Selection instances')
 
-        self.assertEqual(len(b), 5,
-            'parsePfamPDBs failed to return a list of length 5')
+#         self.assertEqual(len(b), 5,
+#             'parsePfamPDBs failed to return a list of length 5')
 
 
-    def testUniprotDefault(self):
-        """Test the outcome of parsing PDBs for a tiny family 
-        of ABC class ATPase N-terminal domains (5 members) 
-        with the Uniprot long ID and default parameters."""
+#     def testUniprotDefault(self):
+#         """Test the outcome of parsing PDBs for a tiny family 
+#         of ABC class ATPase N-terminal domains (5 members) 
+#         with the Uniprot long ID and default parameters."""
 
-        b = parsePfamPDBs(self.queries[1])
+#         b = parsePfamPDBs(self.queries[1])
 
-        self.assertIsInstance(b, list,
-            'parsePfamPDBs failed to return a list instance')
+#         self.assertIsInstance(b, list,
+#             'parsePfamPDBs failed to return a list instance')
 
-        self.assertIsInstance(b[0], Selection,
-            'parsePfamPDBs failed to return a list of Selection instances')
+#         self.assertIsInstance(b[0], Selection,
+#             'parsePfamPDBs failed to return a list of Selection instances')
 
-        self.assertEqual(len(b), 5,
-            'parsePfamPDBs failed to return a list of length 5')
+#         self.assertEqual(len(b), 5,
+#             'parsePfamPDBs failed to return a list of length 5')
 
 
-    def testMultiDomainDefault(self):
-        """Test the outcome of parsing PDBs using a V-type proton ATPase subunit S1, 
-        which has two domains but few relatives. Default parameters should 
-        return Selection objects containing the first domain."""
+#     def testMultiDomainDefault(self):
+#         """Test the outcome of parsing PDBs using a V-type proton ATPase subunit S1, 
+#         which has two domains but few relatives. Default parameters should 
+#         return Selection objects containing the first domain."""
 
-        b = parsePfamPDBs(self.queries[2])
+#         b = parsePfamPDBs(self.queries[2])
 
-        self.assertIsInstance(b, list,
-            'parsePfamPDBs failed to return a list instance')
+#         self.assertIsInstance(b, list,
+#             'parsePfamPDBs failed to return a list instance')
 
-        self.assertIsInstance(b[0], Selection,
-            'parsePfamPDBs failed to return a list of Selection instances')
+#         self.assertIsInstance(b[0], Selection,
+#             'parsePfamPDBs failed to return a list of Selection instances')
 
-        self.assertEqual(b[0].getResnums()[0], 262,
-            'parsePfamPDBs failed to return a first Selection with first resnum 262')
+#         self.assertEqual(b[0].getResnums()[0], 262,
+#             'parsePfamPDBs failed to return a first Selection with first resnum 262')
 
-    def testMultiDomainStart1(self):
-        """Test the outcome of parsing PDBs using a V-type proton ATPase subunit S1, 
-        which has two domains but few relatives. Using start=1 should be like default and 
-        return Selection objects containing the first domain."""
+#     def testMultiDomainStart1(self):
+#         """Test the outcome of parsing PDBs using a V-type proton ATPase subunit S1, 
+#         which has two domains but few relatives. Using start=1 should be like default and 
+#         return Selection objects containing the first domain."""
 
-        b = parsePfamPDBs(self.queries[2], start=1)
+#         b = parsePfamPDBs(self.queries[2], start=1)
 
-        self.assertIsInstance(b, list,
-            'parsePfamPDBs failed to return a list instance')
+#         self.assertIsInstance(b, list,
+#             'parsePfamPDBs failed to return a list instance')
 
-        self.assertIsInstance(b[0], Selection,
-            'parsePfamPDBs failed to return a list of Selection instances')
+#         self.assertIsInstance(b[0], Selection,
+#             'parsePfamPDBs failed to return a list of Selection instances')
 
-        self.assertEqual(b[0].getResnums()[0], 262,
-            'parsePfamPDBs failed to return a first Selection with first resnum 262')
+#         self.assertEqual(b[0].getResnums()[0], 262,
+#             'parsePfamPDBs failed to return a first Selection with first resnum 262')
 
-    def testMultiDomainStart2(self):
-        """Test the outcome of parsing PDBs using a V-type proton ATPase subunit S1, 
-        which has two domains but few relatives. Setting start to 418 should 
-        return Selection objects containing the second domain."""
+#     def testMultiDomainStart2(self):
+#         """Test the outcome of parsing PDBs using a V-type proton ATPase subunit S1, 
+#         which has two domains but few relatives. Setting start to 418 should 
+#         return Selection objects containing the second domain."""
 
-        b = parsePfamPDBs(self.queries[2], start=418)
+#         b = parsePfamPDBs(self.queries[2], start=418)
 
-        self.assertIsInstance(b, list,
-            'parsePfamPDBs failed to return a list instance')
+#         self.assertIsInstance(b, list,
+#             'parsePfamPDBs failed to return a list instance')
 
-        self.assertIsInstance(b[0], Selection,
-            'parsePfamPDBs failed to return a list of Selection instances')
+#         self.assertIsInstance(b[0], Selection,
+#             'parsePfamPDBs failed to return a list of Selection instances')
 
-        self.assertEqual(b[0].getResnums()[0], 418,
-            'parsePfamPDBs failed to return a first Selection with first resnum 418')
+#         self.assertEqual(b[0].getResnums()[0], 418,
+#             'parsePfamPDBs failed to return a first Selection with first resnum 418')
 
-    @classmethod
-    def tearDownClass(self):
-        os.chdir('..')
-        shutil.rmtree(self.workdir)
+#     @classmethod
+#     def tearDownClass(self):
+#         os.chdir('..')
+#         shutil.rmtree(self.workdir)