diff options
author | Brett Cannon <brett@python.org> | 2012-07-20 18:48:53 (GMT) |
---|---|---|
committer | Brett Cannon <brett@python.org> | 2012-07-20 18:48:53 (GMT) |
commit | 45a5e3afe52ed89f298242143c5f7e2bb992ac63 (patch) | |
tree | 2255a23f991f1452335d865939f6c30d7b2d7d48 /Lib/importlib/test/test_api.py | |
parent | 4afc1c08d04a9c083b654178ea4f947563510836 (diff) | |
download | cpython-45a5e3afe52ed89f298242143c5f7e2bb992ac63.zip cpython-45a5e3afe52ed89f298242143c5f7e2bb992ac63.tar.gz cpython-45a5e3afe52ed89f298242143c5f7e2bb992ac63.tar.bz2 |
Issue #15168: Move importlb.test to test.test_importlib.
This should make the Linux distros happy as it is now easier to leave
importlib's tests out of their base Python distribution.
Diffstat (limited to 'Lib/importlib/test/test_api.py')
-rw-r--r-- | Lib/importlib/test/test_api.py | 183 |
1 files changed, 0 insertions, 183 deletions
diff --git a/Lib/importlib/test/test_api.py b/Lib/importlib/test/test_api.py deleted file mode 100644 index ba2a721..0000000 --- a/Lib/importlib/test/test_api.py +++ /dev/null @@ -1,183 +0,0 @@ -from . import util -import imp -import importlib -from importlib import machinery -import sys -from test import support -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. - - -class FrozenImportlibTests(unittest.TestCase): - - def test_no_frozen_importlib(self): - # Should be able to import w/o _frozen_importlib being defined. - module = support.import_fresh_module('importlib', blocked=['_frozen_importlib']) - self.assertFalse(isinstance(module.__loader__, - machinery.FrozenImporter)) - - -def test_main(): - from test.support import run_unittest - run_unittest(ImportModuleTests, - FindLoaderTests, - InvalidateCacheTests, - FrozenImportlibTests) - - -if __name__ == '__main__': - test_main() |