[Python-checkins] r52189 - sandbox/trunk/import_in_py/test_importer.py

[brett.cannon]

Author: brett.cannon
Date: Thu Oct  5 21:28:51 2006
New Revision: 52189

Modified:
   sandbox/trunk/import_in_py/test_importer.py
Log:
Refactor testing of built-in and frozen importers so a superclass can be used.
Still have to set up for the frozen importers, though.


Modified: sandbox/trunk/import_in_py/test_importer.py
==============================================================================
--- sandbox/trunk/import_in_py/test_importer.py	(original)
+++ sandbox/trunk/import_in_py/test_importer.py	Thu Oct  5 21:28:51 2006
@@ -3,62 +3,83 @@
 import importer
 import sys
 
-class BuiltinImporterTests(unittest.TestCase):
 
-    """Test the built-in module importer."""
+class BuiltinFrozen_Tester(unittest.TestCase):
+
+    """Common test cases for built-in and frozen modules.
+
+    Expected attributes:
+    * self.importer
+        The meta_path importer to test.
+    * self.module_name
+        Name of a module that the importer can import.
+    * self.bad_module_names
+        Sequence of module names that cannot be imported.
+
+    """
 
     def test_find_module_basic(self):
-        # Make sure only built-in modules are found.
-        for name in sys.builtin_module_names:
-            self.failUnless(importer.BuiltinImporter.find_module(name))
-        self.failUnless(not importer.BuiltinImporter.find_module('time'),
-                        'incorrectly found an extension module')
-        self.failUnless(not importer.BuiltinImporter.find_module('token'),
-                        'incorrectly found a Python module')
+        # Make sure expected modules can be found.
+        self.failUnless(self.importer.find_module(self.module_name))
+
+    def test_find_module_failures(self):
+        # Modules of the wrong type should not be found.
+        for module_name in self.bad_module_names:
+            self.failUnlessEqual(self.importer.find_module(module_name), None)
+
+    def test_find_module_arg_count(self):
         # Cover proper number of arguments.
-        self.failUnlessRaises(TypeError, importer.BuiltinImporter.find_module)
-        self.failUnlessRaises(TypeError, importer.BuiltinImporter.find_module,
-                                'sys', None, None)
+        self.failUnlessRaises(TypeError, self.importer.find_module)
+        self.failUnlessRaises(TypeError, self.importer.find_module,
+                                self.module_name, None, None)
 
     def test_find_module_path_shortcut(self):
         # Test short-circuiting of finding a module if 'path' argument is given
         # a value.
-        self.failUnless(not importer.BuiltinImporter.find_module('sys', ''))
+        self.failUnless(not self.importer.find_module(self.module_name, ''))
 
     def test_load_module_prev_import_check(self):
-        # If a module is already in 'sys' it should be returned without being
-        # re-initialized.
-        self.failUnlessEqual(importer.BuiltinImporter.load_module('sys'),
-                             sys.modules['sys'])
+        # If a module is already in sys.modules it should be returned without
+        # being re-initialized.
+        self.failUnlessEqual(self.importer.load_module(self.module_name),
+                             sys.modules[self.module_name])
 
     def test_load_module_new_import(self):
-        # Make sure importing of a built-in that was not done before works
+        # Make sure importing of a modules -in that was not done before works
         # properly.
         try:
-            del sys.modules['sys']
+            del sys.modules[self.module_name]
         except KeyError:
             pass
-        sys_module = importer.BuiltinImporter.load_module('sys')
-        self.failUnless(sys_module)
-        self.failUnless(hasattr(sys_module, 'version'))
+        loaded_module = self.importer.load_module(self.module_name)
+        self.failUnlessEqual(self.module_name, loaded_module.__name__)
 
     def test_load_module_no_path_argument(self):
         # TypeError should be raise if 'path' argument set.
-        self.failUnlessRaises(TypeError, importer.BuiltinImporter.load_module,
-                                'sys', '')
+        self.failUnlessRaises(TypeError, self.importer.load_module,
+                                self.module_name, '')
 
     def test_load_module_ImportError(self):
         self.failUnlessRaises(ImportError,
-                                importer.BuiltinImporter.load_module,
-                                'gobbledeegook')
+                                self.importer.load_module,
+                                self.bad_module_names[0])
 
     def test_load_module_arg_count(self):
-        self.failUnlessRaises(TypeError, importer.BuiltinImporter.load_module)
-        self.failUnlessRaises(TypeError, importer.BuiltinImporter.load_module,
-                                'sys', None, None)
+        self.failUnlessRaises(TypeError, self.importer.load_module)
+        self.failUnlessRaises(TypeError, self.importer.load_module,
+                                self.module_name, None, None)
+
+
+class BuiltinImporterTests(BuiltinFrozen_Tester):
+
+    """Test the built-in module importer."""
+
+    importer = importer.BuiltinImporter
+    module_name = 'sys'
+    bad_module_names = ('tokenize', 'time', '__hello__')
 
 
-class FrozenImporterTests(unittest.TestCase):
+class FrozenImporterTests(BuiltinFrozen_Tester):
 
     """Test the frozen module importer.