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

[brett.cannon]

Author: brett.cannon
Date: Thu Nov  9 23:46:38 2006
New Revision: 52713

Modified:
   sandbox/trunk/import_in_py/importer.py
   sandbox/trunk/import_in_py/test_importer.py
Log:
Add tests to verify that the returned module from the Import class is correct
based on whether fromlist is set or not.


Modified: sandbox/trunk/import_in_py/importer.py
==============================================================================
--- sandbox/trunk/import_in_py/importer.py	(original)
+++ sandbox/trunk/import_in_py/importer.py	Thu Nov  9 23:46:38 2006
@@ -73,10 +73,6 @@
   
 XXX Need to Implement
 ---------------------
-#. Importing module within a package.
-    + One package deep.
-    + Arbitrarily deep.
-#. fromlist semantics.
 #. Relative imports.
     + Py3K semantics.
     + 2.x semantics.

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 Nov  9 23:46:38 2006
@@ -663,60 +663,69 @@
 
     """
 
+    def setUp(self):
+        ImportHelper.setUp(self)
+        self.parent_name = '<parent>'
+        self.child_name = '<child>'
+        self.full_child_name = '.'.join([self.parent_name, self.child_name])
+        self.parent_module = mock_importer.MockModule(self.parent_name)
+        self.child_module = mock_importer.MockModule(self.full_child_name)
+        setattr(self.parent_module, self.child_name, self.child_module)
+
     def test_sys_module_return(self):
         # A module found in sys.modules should be returned immediately.
-        test_module = '<test>'
-        sys.modules[test_module] = test_module
-        module = self.importer.import_('<test>')
-        del sys.modules[test_module]
-        self.failUnlessEqual(module, test_module)
+        sys.modules[self.parent_name] = self.parent_module
+        module = self.importer.import_(self.parent_name)
+        self.failUnless(module is self.parent_module)
         
     def test_parent_missing(self):
         # An import should fail if a parent module cannot be found.
-        sys.modules['a.b'] = 'a.b'
-        self.failUnlessRaises(ImportError, self.importer, 'a.b')
+        sys.modules[self.full_child_name] = self.child_module
+        self.failUnlessRaises(ImportError, self.importer, self.full_child_name)
         
     def test_parent_imported(self):
         # If a parent module is already imported, importing a child module
         # should work (along with setting the attribute on the parent for the
         # child module).
+        delattr(self.parent_module, self.child_name)
         succeed_importer = mock_importer.SucceedImporter()
         sys.meta_path.append(succeed_importer)
-        parent_name = '<parent>'
-        parent_module = mock_importer.MockModule(parent_name)
-        sys.modules[parent_name] = parent_module
-        child_name = 'module'
-        full_child_name = parent_name + '.' + child_name
-        self.importer(full_child_name)
-        self.failUnless(hasattr(parent_module, child_name))
-        self.failUnlessEqual(getattr(parent_module, child_name),
-                                sys.modules[full_child_name])
-        
+        sys.modules[self.parent_name] = self.parent_module
+        self.importer(self.full_child_name)
+        self.failUnless(hasattr(self.parent_module, self.child_name))
+        self.failUnlessEqual(getattr(self.parent_module, self.child_name),
+                                sys.modules[self.full_child_name])
+
     def test_parent_not_imported(self):
         # If a parent module is not imported yet, it should be imported.
         # The attribute on the parent module for the child module should also
         # be set.
+        delattr(self.parent_module, self.child_name)
         succeed_importer = mock_importer.SucceedImporter()
         sys.meta_path.append(succeed_importer)
-        parent_name = '<parent>'
-        child_name = '<child>'
-        full_child_name = '.'.join([parent_name, child_name])
-        self.importer(full_child_name)
-        self.failUnless(parent_name in sys.modules)
-        self.failUnless(full_child_name in sys.modules)
-        self.failUnless(hasattr(sys.modules[parent_name], child_name))
-        self.failUnlessEqual(getattr(sys.modules[parent_name], child_name),
-                                sys.modules[full_child_name])
+        self.importer(self.full_child_name)
+        self.failUnless(self.parent_name in sys.modules)
+        self.failUnless(self.full_child_name in sys.modules)
+        self.failUnless(hasattr(sys.modules[self.parent_name], self.child_name))
+        self.failUnlessEqual(getattr(sys.modules[self.parent_name],
+                                        self.child_name),
+                                sys.modules[self.full_child_name])
 
     def test_empty_fromlist(self):
         # An empty fromlist means that the root module is returned.
-        # XXX
-        pass
+        sys.modules[self.parent_name] = self.parent_module
+        sys.modules[self.full_child_name] = self.child_module
+        module = self.importer(self.full_child_name)
+        self.failUnless(module is self.parent_module)
 
     def test_nonempty_fromlist(self):
         # A fromlist with values should return the specified module.
-        # XXX
-        pass
+        sys.modules[self.parent_name] = self.parent_module
+        sys.modules[self.full_child_name] = self.child_module
+        test_attr_name = 'test_attr'
+        setattr(self.child_module, test_attr_name, None)
+        module = self.importer(self.full_child_name, fromlist=[test_attr_name])
+        self.failUnless(module is self.child_module)
 
           
 class ImportMetaPathTests(ImportHelper):