| from . import util |
| import imp |
| import importlib |
| import sys |
| import unittest |
| |
| |
| class ImportModuleTests(unittest.TestCase): |
| |
| """Test importlib.import_module.""" |
| |
| def test_module_import(self): |
| # Test importing a top-level module. |
| with util.mock_modules('top_level') as mock: |
| with util.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 util.mock_modules(pkg_long_name, name) as mock: |
| with util.import_state(meta_path=[mock]): |
| module = importlib.import_module(name) |
| self.assertEqual(module.__name__, name) |
| |
| def test_shallow_relative_package_import(self): |
| # Test importing a module from a package through a relative import. |
| pkg_name = 'pkg' |
| pkg_long_name = '{0}.__init__'.format(pkg_name) |
| module_name = 'mod' |
| absolute_name = '{0}.{1}'.format(pkg_name, module_name) |
| relative_name = '.{0}'.format(module_name) |
| with util.mock_modules(pkg_long_name, absolute_name) as mock: |
| with util.import_state(meta_path=[mock]): |
| importlib.import_module(pkg_name) |
| module = importlib.import_module(relative_name, pkg_name) |
| self.assertEqual(module.__name__, absolute_name) |
| |
| def test_deep_relative_package_import(self): |
| modules = ['a.__init__', 'a.b.__init__', 'a.c'] |
| with util.mock_modules(*modules) as mock: |
| with util.import_state(meta_path=[mock]): |
| importlib.import_module('a') |
| importlib.import_module('a.b') |
| 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 util.mock_modules(pkg_long_name, name) as mock: |
| with util.import_state(meta_path=[mock]): |
| importlib.import_module(pkg_name) |
| 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. |
| with self.assertRaises(TypeError): |
| importlib.import_module('.support') |
| |
| |
| def test_loaded_once(self): |
| # Issue #13591: Modules should only be loaded once when |
| # initializing the parent package attempts to import the |
| # module currently being imported. |
| b_load_count = 0 |
| def load_a(): |
| importlib.import_module('a.b') |
| def load_b(): |
| nonlocal b_load_count |
| b_load_count += 1 |
| code = {'a': load_a, 'a.b': load_b} |
| modules = ['a.__init__', 'a.b'] |
| with util.mock_modules(*modules, module_code=code) as mock: |
| with util.import_state(meta_path=[mock]): |
| importlib.import_module('a.b') |
| self.assertEqual(b_load_count, 1) |
| |
| |
| class FindLoaderTests(unittest.TestCase): |
| |
| class FakeMetaFinder: |
| @staticmethod |
| def find_module(name, path=None): return name, path |
| |
| def test_sys_modules(self): |
| # If a module with __loader__ is in sys.modules, then return it. |
| name = 'some_mod' |
| with util.uncache(name): |
| module = imp.new_module(name) |
| loader = 'a loader!' |
| module.__loader__ = loader |
| sys.modules[name] = module |
| found = importlib.find_loader(name) |
| self.assertEqual(loader, found) |
| |
| def test_sys_modules_loader_is_None(self): |
| # If sys.modules[name].__loader__ is None, raise ValueError. |
| name = 'some_mod' |
| with util.uncache(name): |
| module = imp.new_module(name) |
| module.__loader__ = None |
| sys.modules[name] = module |
| with self.assertRaises(ValueError): |
| importlib.find_loader(name) |
| |
| def test_success(self): |
| # Return the loader found on sys.meta_path. |
| name = 'some_mod' |
| with util.uncache(name): |
| with util.import_state(meta_path=[self.FakeMetaFinder]): |
| self.assertEqual((name, None), importlib.find_loader(name)) |
| |
| def test_success_path(self): |
| # Searching on a path should work. |
| name = 'some_mod' |
| path = 'path to some place' |
| with util.uncache(name): |
| with util.import_state(meta_path=[self.FakeMetaFinder]): |
| self.assertEqual((name, path), |
| importlib.find_loader(name, path)) |
| |
| def test_nothing(self): |
| # None is returned upon failure to find a loader. |
| self.assertIsNone(importlib.find_loader('nevergoingtofindthismodule')) |
| |
| |
| class InvalidateCacheTests(unittest.TestCase): |
| |
| def test_method_called(self): |
| # If defined the method should be called. |
| class InvalidatingNullFinder: |
| def __init__(self, *ignored): |
| self.called = False |
| def find_module(self, *args): |
| return None |
| def invalidate_caches(self): |
| self.called = True |
| |
| key = 'gobledeegook' |
| ins = InvalidatingNullFinder() |
| sys.path_importer_cache[key] = ins |
| self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key)) |
| importlib.invalidate_caches() |
| self.assertTrue(ins.called) |
| |
| def test_method_lacking(self): |
| # There should be no issues if the method is not defined. |
| key = 'gobbledeegook' |
| sys.path_importer_cache[key] = imp.NullImporter('abc') |
| self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key)) |
| importlib.invalidate_caches() # Shouldn't trigger an exception. |
| |
| |
| def test_main(): |
| from test.support import run_unittest |
| run_unittest(ImportModuleTests, FindLoaderTests, InvalidateCacheTests) |
| |
| |
| if __name__ == '__main__': |
| test_main() |