import contextlib | |
import imp | |
import importlib | |
import sys | |
import unittest | |
@contextlib.contextmanager | |
def uncache(*names): | |
"""Uncache a module from sys.modules. | |
A basic sanity check is performed to prevent uncaching modules that either | |
cannot/shouldn't be uncached. | |
""" | |
for name in names: | |
if name in ('sys', 'marshal', 'imp'): | |
raise ValueError( | |
"cannot uncache {0} as it will break _importlib".format(name)) | |
try: | |
del sys.modules[name] | |
except KeyError: | |
pass | |
try: | |
yield | |
finally: | |
for name in names: | |
try: | |
del sys.modules[name] | |
except KeyError: | |
pass | |
@contextlib.contextmanager | |
def import_state(**kwargs): | |
"""Context manager to manage the various importers and stored state in the | |
sys module. | |
The 'modules' attribute is not supported as the interpreter state stores a | |
pointer to the dict that the interpreter uses internally; | |
reassigning to sys.modules does not have the desired effect. | |
""" | |
originals = {} | |
try: | |
for attr, default in (('meta_path', []), ('path', []), | |
('path_hooks', []), | |
('path_importer_cache', {})): | |
originals[attr] = getattr(sys, attr) | |
if attr in kwargs: | |
new_value = kwargs[attr] | |
del kwargs[attr] | |
else: | |
new_value = default | |
setattr(sys, attr, new_value) | |
if len(kwargs): | |
raise ValueError( | |
'unrecognized arguments: {0}'.format(kwargs.keys())) | |
yield | |
finally: | |
for attr, value in originals.items(): | |
setattr(sys, attr, value) | |
class mock_modules(object): | |
"""A mock importer/loader.""" | |
def __init__(self, *names): | |
self.modules = {} | |
for name in names: | |
if not name.endswith('.__init__'): | |
import_name = name | |
else: | |
import_name = name[:-len('.__init__')] | |
if '.' not in name: | |
package = None | |
elif import_name == name: | |
package = name.rsplit('.', 1)[0] | |
else: | |
package = import_name | |
module = imp.new_module(import_name) | |
module.__loader__ = self | |
module.__file__ = '<mock __file__>' | |
module.__package__ = package | |
module.attr = name | |
if import_name != name: | |
module.__path__ = ['<mock __path__>'] | |
self.modules[import_name] = module | |
def __getitem__(self, name): | |
return self.modules[name] | |
def find_module(self, fullname, path=None): | |
if fullname not in self.modules: | |
return None | |
else: | |
return self | |
def load_module(self, fullname): | |
if fullname not in self.modules: | |
raise ImportError | |
else: | |
sys.modules[fullname] = self.modules[fullname] | |
return self.modules[fullname] | |
def __enter__(self): | |
self._uncache = uncache(*self.modules.keys()) | |
self._uncache.__enter__() | |
return self | |
def __exit__(self, *exc_info): | |
self._uncache.__exit__(None, None, None) | |
class ImportModuleTests(unittest.TestCase): | |
"""Test importlib.import_module.""" | |
def test_module_import(self): | |
# Test importing a top-level module. | |
with mock_modules('top_level') as mock: | |
with import_state(meta_path=[mock]): | |
module = importlib.import_module('top_level') | |
self.assertEqual(module.__name__, 'top_level') | |
def test_absolute_package_import(self): | |
# Test importing a module from a package with an absolute name. | |
pkg_name = 'pkg' | |
pkg_long_name = '{0}.__init__'.format(pkg_name) | |
name = '{0}.mod'.format(pkg_name) | |
with mock_modules(pkg_long_name, name) as mock: | |
with import_state(meta_path=[mock]): | |
module = importlib.import_module(name) | |
self.assertEqual(module.__name__, name) | |
def test_shallow_relative_package_import(self): | |
modules = ['a.__init__', 'a.b.__init__', 'a.b.c.__init__', 'a.b.c.d'] | |
with mock_modules(*modules) as mock: | |
with import_state(meta_path=[mock]): | |
module = importlib.import_module('.d', 'a.b.c') | |
self.assertEqual(module.__name__, 'a.b.c.d') | |
def test_deep_relative_package_import(self): | |
# Test importing a module from a package through a relatve import. | |
modules = ['a.__init__', 'a.b.__init__', 'a.c'] | |
with mock_modules(*modules) as mock: | |
with import_state(meta_path=[mock]): | |
module = importlib.import_module('..c', 'a.b') | |
self.assertEqual(module.__name__, 'a.c') | |
def test_absolute_import_with_package(self): | |
# Test importing a module from a package with an absolute name with | |
# the 'package' argument given. | |
pkg_name = 'pkg' | |
pkg_long_name = '{0}.__init__'.format(pkg_name) | |
name = '{0}.mod'.format(pkg_name) | |
with mock_modules(pkg_long_name, name) as mock: | |
with import_state(meta_path=[mock]): | |
module = importlib.import_module(name, pkg_name) | |
self.assertEqual(module.__name__, name) | |
def test_relative_import_wo_package(self): | |
# Relative imports cannot happen without the 'package' argument being | |
# set. | |
self.assertRaises(TypeError, importlib.import_module, '.support') | |
def test_main(): | |
from test.test_support import run_unittest | |
run_unittest(ImportModuleTests) | |
if __name__ == '__main__': | |
test_main() |