diff options
| -rw-r--r-- | django/utils/module_loading.py | 76 | ||||
| -rw-r--r-- | tests/regressiontests/utils/eggs/test_egg.egg | bin | 0 -> 4844 bytes | |||
| -rw-r--r-- | tests/regressiontests/utils/module_loading.py | 139 | ||||
| -rw-r--r-- | tests/regressiontests/utils/test_module/__init__.py | 0 | ||||
| -rw-r--r-- | tests/regressiontests/utils/test_module/bad_module.py | 3 | ||||
| -rw-r--r-- | tests/regressiontests/utils/test_module/good_module.py | 1 | ||||
| -rw-r--r-- | tests/regressiontests/utils/tests.py | 1 |
7 files changed, 199 insertions, 21 deletions
diff --git a/django/utils/module_loading.py b/django/utils/module_loading.py index e8bc41ca31..f251035387 100644 --- a/django/utils/module_loading.py +++ b/django/utils/module_loading.py @@ -1,26 +1,60 @@ -import os import imp +import os +import sys -def module_has_submodule(mod, submod_name): - # If the module was loaded from an egg, __loader__ will be set and - # its find_module must be used to search for submodules. - loader = getattr(mod, '__loader__', None) - if loader: - mod_path = "%s.%s" % (mod.__name__[mod.__name__.rfind('.')+1:], submod_name) - x = loader.find_module(mod_path) - if x is None: - # zipimport.zipimporter.find_module is documented to take - # dotted paths but in fact through Python 2.7 is observed - # to require os.sep in place of dots...so try using os.sep - # if the dotted path version failed to find the requested - # submodule. - x = loader.find_module(mod_path.replace('.', os.sep)) - return x is not None - try: - imp.find_module(submod_name, mod.__path__) +def module_has_submodule(package, module_name): + """See if 'module' is in 'package'.""" + name = ".".join([package.__name__, module_name]) + if name in sys.modules: return True - except ImportError: + for finder in sys.meta_path: + if finder.find_module(name): + return True + for entry in package.__path__: # No __path__, then not a package. + try: + # Try the cached finder. + finder = sys.path_importer_cache[entry] + if finder is None: + # Implicit import machinery should be used. + try: + file_, _, _ = imp.find_module(module_name, [entry]) + if file_: + file_.close() + return True + except ImportError: + continue + # Else see if the finder knows of a loader. + elif finder.find_module(name): + return True + else: + continue + except KeyError: + # No cached finder, so try and make one. + for hook in sys.path_hooks: + try: + finder = hook(entry) + # XXX Could cache in sys.path_importer_cache + if finder.find_module(name): + return True + else: + # Once a finder is found, stop the search. + break + except ImportError: + # Continue the search for a finder. + continue + else: + # No finder found. + # Try the implicit import machinery if searching a directory. + if os.path.isdir(entry): + try: + file_, _, _ = imp.find_module(module_name, [entry]) + if file_: + file_.close() + return True + except ImportError: + pass + # XXX Could insert None or NullImporter + else: + # Exhausted the search, so the module cannot be found. return False - - diff --git a/tests/regressiontests/utils/eggs/test_egg.egg b/tests/regressiontests/utils/eggs/test_egg.egg Binary files differnew file mode 100644 index 0000000000..9b08cc10ef --- /dev/null +++ b/tests/regressiontests/utils/eggs/test_egg.egg diff --git a/tests/regressiontests/utils/module_loading.py b/tests/regressiontests/utils/module_loading.py new file mode 100644 index 0000000000..7b233f8e14 --- /dev/null +++ b/tests/regressiontests/utils/module_loading.py @@ -0,0 +1,139 @@ +import os +import sys +from unittest import TestCase +from zipimport import zipimporter + +from django.utils.importlib import import_module +from django.utils.module_loading import module_has_submodule + +class DefaultLoader(TestCase): + def test_loader(self): + "Normal module existence can be tested" + test_module = import_module('regressiontests.utils.test_module') + + # An importable child + self.assertTrue(module_has_submodule(test_module, 'good_module')) + mod = import_module('regressiontests.utils.test_module.good_module') + self.assertEqual(mod.content, 'Good Module') + + # A child that exists, but will generate an import error if loaded + self.assertTrue(module_has_submodule(test_module, 'bad_module')) + self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.bad_module') + + # A child that doesn't exist + self.assertFalse(module_has_submodule(test_module, 'no_such_module')) + self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.no_such_module') + +class EggLoader(TestCase): + def setUp(self): + self.old_path = sys.path + self.egg_dir = '%s/eggs' % os.path.dirname(__file__) + + def tearDown(self): + sys.path = self.old_path + + def test_shallow_loader(self): + "Module existence can be tested inside eggs" + egg_name = '%s/test_egg.egg' % self.egg_dir + sys.path.append(egg_name) + egg_module = import_module('egg_module') + + # An importable child + self.assertTrue(module_has_submodule(egg_module, 'good_module')) + mod = import_module('egg_module.good_module') + self.assertEqual(mod.content, 'Good Module') + + # A child that exists, but will generate an import error if loaded + self.assertTrue(module_has_submodule(egg_module, 'bad_module')) + self.assertRaises(ImportError, import_module, 'egg_module.bad_module') + + # A child that doesn't exist + self.assertFalse(module_has_submodule(egg_module, 'no_such_module')) + self.assertRaises(ImportError, import_module, 'egg_module.no_such_module') + + def test_deep_loader(self): + "Modules deep inside an egg can still be tested for existence" + egg_name = '%s/test_egg.egg' % self.egg_dir + sys.path.append(egg_name) + egg_module = import_module('egg_module.sub1.sub2') + + # An importable child + self.assertTrue(module_has_submodule(egg_module, 'good_module')) + mod = import_module('egg_module.sub1.sub2.good_module') + self.assertEqual(mod.content, 'Deep Good Module') + + # A child that exists, but will generate an import error if loaded + self.assertTrue(module_has_submodule(egg_module, 'bad_module')) + self.assertRaises(ImportError, import_module, 'egg_module.sub1.sub2.bad_module') + + # A child that doesn't exist + self.assertFalse(module_has_submodule(egg_module, 'no_such_module')) + self.assertRaises(ImportError, import_module, 'egg_module.sub1.sub2.no_such_module') + +class TestFinder(object): + def __init__(self, *args, **kwargs): + self.importer = zipimporter(*args, **kwargs) + + def find_module(self, path): + importer = self.importer.find_module(path) + if importer is None: + return + return TestLoader(importer) + +class TestLoader(object): + def __init__(self, importer): + self.importer = importer + + def load_module(self, name): + mod = self.importer.load_module(name) + mod.__loader__ = self + return mod + +class CustomLoader(TestCase): + def setUp(self): + self.egg_dir = '%s/eggs' % os.path.dirname(__file__) + self.old_path = sys.path + sys.path_hooks.insert(0, TestFinder) + sys.path_importer_cache.clear() + + def tearDown(self): + sys.path = self.old_path + sys.path_hooks.pop(0) + + def test_shallow_loader(self): + "Module existence can be tested with a custom loader" + egg_name = '%s/test_egg.egg' % self.egg_dir + sys.path.append(egg_name) + egg_module = import_module('egg_module') + + # An importable child + self.assertTrue(module_has_submodule(egg_module, 'good_module')) + mod = import_module('egg_module.good_module') + self.assertEqual(mod.content, 'Good Module') + + # A child that exists, but will generate an import error if loaded + self.assertTrue(module_has_submodule(egg_module, 'bad_module')) + self.assertRaises(ImportError, import_module, 'egg_module.bad_module') + + # A child that doesn't exist + self.assertFalse(module_has_submodule(egg_module, 'no_such_module')) + self.assertRaises(ImportError, import_module, 'egg_module.no_such_module') + + def test_deep_loader(self): + "Modules existence can be tested deep inside a custom loader" + egg_name = '%s/test_egg.egg' % self.egg_dir + sys.path.append(egg_name) + egg_module = import_module('egg_module.sub1.sub2') + + # An importable child + self.assertTrue(module_has_submodule(egg_module, 'good_module')) + mod = import_module('egg_module.sub1.sub2.good_module') + self.assertEqual(mod.content, 'Deep Good Module') + + # A child that exists, but will generate an import error if loaded + self.assertTrue(module_has_submodule(egg_module, 'bad_module')) + self.assertRaises(ImportError, import_module, 'egg_module.sub1.sub2.bad_module') + + # A child that doesn't exist + self.assertFalse(module_has_submodule(egg_module, 'no_such_module')) + self.assertRaises(ImportError, import_module, 'egg_module.sub1.sub2.no_such_module') diff --git a/tests/regressiontests/utils/test_module/__init__.py b/tests/regressiontests/utils/test_module/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/regressiontests/utils/test_module/__init__.py diff --git a/tests/regressiontests/utils/test_module/bad_module.py b/tests/regressiontests/utils/test_module/bad_module.py new file mode 100644 index 0000000000..cc0cd168ce --- /dev/null +++ b/tests/regressiontests/utils/test_module/bad_module.py @@ -0,0 +1,3 @@ +import a_package_name_that_does_not_exist + +content = 'Bad Module'
\ No newline at end of file diff --git a/tests/regressiontests/utils/test_module/good_module.py b/tests/regressiontests/utils/test_module/good_module.py new file mode 100644 index 0000000000..0ca689832a --- /dev/null +++ b/tests/regressiontests/utils/test_module/good_module.py @@ -0,0 +1 @@ +content = 'Good Module'
\ No newline at end of file diff --git a/tests/regressiontests/utils/tests.py b/tests/regressiontests/utils/tests.py index 812276b554..edbc2792bf 100644 --- a/tests/regressiontests/utils/tests.py +++ b/tests/regressiontests/utils/tests.py @@ -32,6 +32,7 @@ __test__ = { from dateformat import * from feedgenerator import * +from module_loading import * class TestUtilsHtml(TestCase): |