mirror of https://github.com/python/cpython
584 lines
23 KiB
Python
584 lines
23 KiB
Python
from . import util
|
|
|
|
frozen_init, source_init = util.import_importlib('importlib')
|
|
frozen_util, source_util = util.import_importlib('importlib.util')
|
|
frozen_machinery, source_machinery = util.import_importlib('importlib.machinery')
|
|
|
|
from contextlib import contextmanager
|
|
import os.path
|
|
import sys
|
|
from test import support
|
|
import types
|
|
import unittest
|
|
import warnings
|
|
|
|
|
|
@contextmanager
|
|
def temp_module(name, content='', *, pkg=False):
|
|
conflicts = [n for n in sys.modules if n.partition('.')[0] == name]
|
|
with support.temp_cwd(None) as cwd:
|
|
with util.uncache(name, *conflicts):
|
|
with support.DirsOnSysPath(cwd):
|
|
frozen_init.invalidate_caches()
|
|
|
|
location = os.path.join(cwd, name)
|
|
if pkg:
|
|
modpath = os.path.join(location, '__init__.py')
|
|
os.mkdir(name)
|
|
else:
|
|
modpath = location + '.py'
|
|
if content is None:
|
|
# Make sure the module file gets created.
|
|
content = ''
|
|
if content is not None:
|
|
# not a namespace package
|
|
with open(modpath, 'w') as modfile:
|
|
modfile.write(content)
|
|
yield location
|
|
|
|
|
|
def submodule(parent, name, pkg_dir, content=''):
|
|
path = os.path.join(pkg_dir, name + '.py')
|
|
with open(path, 'w') as subfile:
|
|
subfile.write(content)
|
|
return '{}.{}'.format(parent, name), path
|
|
|
|
|
|
class ImportModuleTests:
|
|
|
|
"""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 = self.init.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 = self.init.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]):
|
|
self.init.import_module(pkg_name)
|
|
module = self.init.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]):
|
|
self.init.import_module('a')
|
|
self.init.import_module('a.b')
|
|
module = self.init.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]):
|
|
self.init.import_module(pkg_name)
|
|
module = self.init.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):
|
|
self.init.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():
|
|
self.init.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]):
|
|
self.init.import_module('a.b')
|
|
self.assertEqual(b_load_count, 1)
|
|
|
|
class Frozen_ImportModuleTests(ImportModuleTests, unittest.TestCase):
|
|
init = frozen_init
|
|
|
|
class Source_ImportModuleTests(ImportModuleTests, unittest.TestCase):
|
|
init = source_init
|
|
|
|
|
|
class FindLoaderTests:
|
|
|
|
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 = types.ModuleType(name)
|
|
loader = 'a loader!'
|
|
module.__loader__ = loader
|
|
sys.modules[name] = module
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('ignore', DeprecationWarning)
|
|
found = self.init.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 = types.ModuleType(name)
|
|
module.__loader__ = None
|
|
sys.modules[name] = module
|
|
with self.assertRaises(ValueError):
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('ignore', DeprecationWarning)
|
|
self.init.find_loader(name)
|
|
|
|
def test_sys_modules_loader_is_not_set(self):
|
|
# Should raise ValueError
|
|
# Issue #17099
|
|
name = 'some_mod'
|
|
with util.uncache(name):
|
|
module = types.ModuleType(name)
|
|
try:
|
|
del module.__loader__
|
|
except AttributeError:
|
|
pass
|
|
sys.modules[name] = module
|
|
with self.assertRaises(ValueError):
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('ignore', DeprecationWarning)
|
|
self.init.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]):
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('ignore', DeprecationWarning)
|
|
self.assertEqual((name, None), self.init.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]):
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('ignore', DeprecationWarning)
|
|
self.assertEqual((name, path),
|
|
self.init.find_loader(name, path))
|
|
|
|
def test_nothing(self):
|
|
# None is returned upon failure to find a loader.
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('ignore', DeprecationWarning)
|
|
self.assertIsNone(self.init.find_loader('nevergoingtofindthismodule'))
|
|
|
|
class Frozen_FindLoaderTests(FindLoaderTests, unittest.TestCase):
|
|
init = frozen_init
|
|
|
|
class Source_FindLoaderTests(FindLoaderTests, unittest.TestCase):
|
|
init = source_init
|
|
|
|
|
|
class FindSpecTests:
|
|
|
|
class FakeMetaFinder:
|
|
@staticmethod
|
|
def find_spec(name, path=None, target=None): return name, path, target
|
|
|
|
def test_sys_modules(self):
|
|
name = 'some_mod'
|
|
with util.uncache(name):
|
|
module = types.ModuleType(name)
|
|
loader = 'a loader!'
|
|
spec = self.machinery.ModuleSpec(name, loader)
|
|
module.__loader__ = loader
|
|
module.__spec__ = spec
|
|
sys.modules[name] = module
|
|
found = self.init.find_spec(name)
|
|
self.assertEqual(found, spec)
|
|
|
|
def test_sys_modules_without___loader__(self):
|
|
name = 'some_mod'
|
|
with util.uncache(name):
|
|
module = types.ModuleType(name)
|
|
del module.__loader__
|
|
loader = 'a loader!'
|
|
spec = self.machinery.ModuleSpec(name, loader)
|
|
module.__spec__ = spec
|
|
sys.modules[name] = module
|
|
found = self.init.find_spec(name)
|
|
self.assertEqual(found, spec)
|
|
|
|
def test_sys_modules_spec_is_None(self):
|
|
name = 'some_mod'
|
|
with util.uncache(name):
|
|
module = types.ModuleType(name)
|
|
module.__spec__ = None
|
|
sys.modules[name] = module
|
|
with self.assertRaises(ValueError):
|
|
self.init.find_spec(name)
|
|
|
|
def test_sys_modules_loader_is_None(self):
|
|
name = 'some_mod'
|
|
with util.uncache(name):
|
|
module = types.ModuleType(name)
|
|
spec = self.machinery.ModuleSpec(name, None)
|
|
module.__spec__ = spec
|
|
sys.modules[name] = module
|
|
found = self.init.find_spec(name)
|
|
self.assertEqual(found, spec)
|
|
|
|
def test_sys_modules_spec_is_not_set(self):
|
|
name = 'some_mod'
|
|
with util.uncache(name):
|
|
module = types.ModuleType(name)
|
|
try:
|
|
del module.__spec__
|
|
except AttributeError:
|
|
pass
|
|
sys.modules[name] = module
|
|
with self.assertRaises(ValueError):
|
|
self.init.find_spec(name)
|
|
|
|
def test_success(self):
|
|
name = 'some_mod'
|
|
with util.uncache(name):
|
|
with util.import_state(meta_path=[self.FakeMetaFinder]):
|
|
self.assertEqual((name, None, None),
|
|
self.init.find_spec(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, None),
|
|
self.init.find_spec(name, path))
|
|
|
|
def test_nothing(self):
|
|
# None is returned upon failure to find a loader.
|
|
self.assertIsNone(self.init.find_spec('nevergoingtofindthismodule'))
|
|
|
|
def test_find_submodule(self):
|
|
name = 'spam'
|
|
subname = 'ham'
|
|
with temp_module(name, pkg=True) as pkg_dir:
|
|
fullname, _ = submodule(name, subname, pkg_dir)
|
|
spec = self.init.find_spec(fullname, [pkg_dir])
|
|
self.assertIsNot(spec, None)
|
|
self.assertNotIn(name, sorted(sys.modules))
|
|
# Ensure successive calls behave the same.
|
|
spec_again = self.init.find_spec(fullname, [pkg_dir])
|
|
self.assertEqual(spec_again, spec)
|
|
|
|
def test_find_submodule_missing_path(self):
|
|
name = 'spam'
|
|
subname = 'ham'
|
|
with temp_module(name, pkg=True) as pkg_dir:
|
|
fullname, _ = submodule(name, subname, pkg_dir)
|
|
spec = self.init.find_spec(fullname)
|
|
self.assertIs(spec, None)
|
|
self.assertNotIn(name, sorted(sys.modules))
|
|
# Ensure successive calls behave the same.
|
|
spec = self.init.find_spec(fullname)
|
|
self.assertIs(spec, None)
|
|
|
|
|
|
class Frozen_FindSpecTests(FindSpecTests, unittest.TestCase):
|
|
init = frozen_init
|
|
machinery = frozen_machinery
|
|
|
|
class Source_FindSpecTests(FindSpecTests, unittest.TestCase):
|
|
init = source_init
|
|
machinery = source_machinery
|
|
|
|
|
|
class ReloadTests:
|
|
|
|
"""Test module reloading for builtin and extension modules."""
|
|
|
|
def test_reload_modules(self):
|
|
for mod in ('tokenize', 'time', 'marshal'):
|
|
with self.subTest(module=mod):
|
|
with support.CleanImport(mod):
|
|
module = self.init.import_module(mod)
|
|
self.init.reload(module)
|
|
|
|
def test_module_replaced(self):
|
|
def code():
|
|
import sys
|
|
module = type(sys)('top_level')
|
|
module.spam = 3
|
|
sys.modules['top_level'] = module
|
|
mock = util.mock_modules('top_level',
|
|
module_code={'top_level': code})
|
|
with mock:
|
|
with util.import_state(meta_path=[mock]):
|
|
module = self.init.import_module('top_level')
|
|
reloaded = self.init.reload(module)
|
|
actual = sys.modules['top_level']
|
|
self.assertEqual(actual.spam, 3)
|
|
self.assertEqual(reloaded.spam, 3)
|
|
|
|
def test_reload_missing_loader(self):
|
|
with support.CleanImport('types'):
|
|
import types
|
|
loader = types.__loader__
|
|
del types.__loader__
|
|
reloaded = self.init.reload(types)
|
|
|
|
self.assertIs(reloaded, types)
|
|
self.assertIs(sys.modules['types'], types)
|
|
self.assertEqual(reloaded.__loader__.path, loader.path)
|
|
|
|
def test_reload_loader_replaced(self):
|
|
with support.CleanImport('types'):
|
|
import types
|
|
types.__loader__ = None
|
|
self.init.invalidate_caches()
|
|
reloaded = self.init.reload(types)
|
|
|
|
self.assertIsNot(reloaded.__loader__, None)
|
|
self.assertIs(reloaded, types)
|
|
self.assertIs(sys.modules['types'], types)
|
|
|
|
def test_reload_location_changed(self):
|
|
name = 'spam'
|
|
with support.temp_cwd(None) as cwd:
|
|
with util.uncache('spam'):
|
|
with support.DirsOnSysPath(cwd):
|
|
# Start as a plain module.
|
|
self.init.invalidate_caches()
|
|
path = os.path.join(cwd, name + '.py')
|
|
cached = self.util.cache_from_source(path)
|
|
expected = {'__name__': name,
|
|
'__package__': '',
|
|
'__file__': path,
|
|
'__cached__': cached,
|
|
'__doc__': None,
|
|
'__builtins__': __builtins__,
|
|
}
|
|
support.create_empty_file(path)
|
|
module = self.init.import_module(name)
|
|
ns = vars(module)
|
|
loader = ns.pop('__loader__')
|
|
spec = ns.pop('__spec__')
|
|
self.assertEqual(spec.name, name)
|
|
self.assertEqual(spec.loader, loader)
|
|
self.assertEqual(loader.path, path)
|
|
self.assertEqual(ns, expected)
|
|
|
|
# Change to a package.
|
|
self.init.invalidate_caches()
|
|
init_path = os.path.join(cwd, name, '__init__.py')
|
|
cached = self.util.cache_from_source(init_path)
|
|
expected = {'__name__': name,
|
|
'__package__': name,
|
|
'__file__': init_path,
|
|
'__cached__': cached,
|
|
'__path__': [os.path.dirname(init_path)],
|
|
'__doc__': None,
|
|
'__builtins__': __builtins__,
|
|
}
|
|
os.mkdir(name)
|
|
os.rename(path, init_path)
|
|
reloaded = self.init.reload(module)
|
|
ns = vars(reloaded)
|
|
loader = ns.pop('__loader__')
|
|
spec = ns.pop('__spec__')
|
|
self.assertEqual(spec.name, name)
|
|
self.assertEqual(spec.loader, loader)
|
|
self.assertIs(reloaded, module)
|
|
self.assertEqual(loader.path, init_path)
|
|
self.maxDiff = None
|
|
self.assertEqual(ns, expected)
|
|
|
|
def test_reload_namespace_changed(self):
|
|
name = 'spam'
|
|
with support.temp_cwd(None) as cwd:
|
|
with util.uncache('spam'):
|
|
with support.DirsOnSysPath(cwd):
|
|
# Start as a namespace package.
|
|
self.init.invalidate_caches()
|
|
bad_path = os.path.join(cwd, name, '__init.py')
|
|
cached = self.util.cache_from_source(bad_path)
|
|
expected = {'__name__': name,
|
|
'__package__': name,
|
|
'__doc__': None,
|
|
}
|
|
os.mkdir(name)
|
|
with open(bad_path, 'w') as init_file:
|
|
init_file.write('eggs = None')
|
|
module = self.init.import_module(name)
|
|
ns = vars(module)
|
|
loader = ns.pop('__loader__')
|
|
path = ns.pop('__path__')
|
|
spec = ns.pop('__spec__')
|
|
self.assertEqual(spec.name, name)
|
|
self.assertIs(spec.loader, None)
|
|
self.assertIsNot(loader, None)
|
|
self.assertEqual(set(path),
|
|
set([os.path.dirname(bad_path)]))
|
|
with self.assertRaises(AttributeError):
|
|
# a NamespaceLoader
|
|
loader.path
|
|
self.assertEqual(ns, expected)
|
|
|
|
# Change to a regular package.
|
|
self.init.invalidate_caches()
|
|
init_path = os.path.join(cwd, name, '__init__.py')
|
|
cached = self.util.cache_from_source(init_path)
|
|
expected = {'__name__': name,
|
|
'__package__': name,
|
|
'__file__': init_path,
|
|
'__cached__': cached,
|
|
'__path__': [os.path.dirname(init_path)],
|
|
'__doc__': None,
|
|
'__builtins__': __builtins__,
|
|
'eggs': None,
|
|
}
|
|
os.rename(bad_path, init_path)
|
|
reloaded = self.init.reload(module)
|
|
ns = vars(reloaded)
|
|
loader = ns.pop('__loader__')
|
|
spec = ns.pop('__spec__')
|
|
self.assertEqual(spec.name, name)
|
|
self.assertEqual(spec.loader, loader)
|
|
self.assertIs(reloaded, module)
|
|
self.assertEqual(loader.path, init_path)
|
|
self.assertEqual(ns, expected)
|
|
|
|
def test_reload_submodule(self):
|
|
# See #19851.
|
|
name = 'spam'
|
|
subname = 'ham'
|
|
with temp_module(name, pkg=True) as pkg_dir:
|
|
fullname, _ = submodule(name, subname, pkg_dir)
|
|
ham = self.init.import_module(fullname)
|
|
reloaded = self.init.reload(ham)
|
|
self.assertIs(reloaded, ham)
|
|
|
|
|
|
class Frozen_ReloadTests(ReloadTests, unittest.TestCase):
|
|
init = frozen_init
|
|
util = frozen_util
|
|
|
|
class Source_ReloadTests(ReloadTests, unittest.TestCase):
|
|
init = source_init
|
|
util = source_util
|
|
|
|
|
|
class InvalidateCacheTests:
|
|
|
|
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'
|
|
meta_ins = InvalidatingNullFinder()
|
|
path_ins = InvalidatingNullFinder()
|
|
sys.meta_path.insert(0, meta_ins)
|
|
self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key))
|
|
sys.path_importer_cache[key] = path_ins
|
|
self.addCleanup(lambda: sys.meta_path.remove(meta_ins))
|
|
self.init.invalidate_caches()
|
|
self.assertTrue(meta_ins.called)
|
|
self.assertTrue(path_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] = None
|
|
self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key))
|
|
self.init.invalidate_caches() # Shouldn't trigger an exception.
|
|
|
|
class Frozen_InvalidateCacheTests(InvalidateCacheTests, unittest.TestCase):
|
|
init = frozen_init
|
|
|
|
class Source_InvalidateCacheTests(InvalidateCacheTests, unittest.TestCase):
|
|
init = source_init
|
|
|
|
|
|
class FrozenImportlibTests(unittest.TestCase):
|
|
|
|
def test_no_frozen_importlib(self):
|
|
# Should be able to import w/o _frozen_importlib being defined.
|
|
# Can't do an isinstance() check since separate copies of importlib
|
|
# may have been used for import, so just check the name is not for the
|
|
# frozen loader.
|
|
self.assertNotEqual(source_init.__loader__.__class__.__name__,
|
|
'FrozenImporter')
|
|
|
|
|
|
class StartupTests:
|
|
|
|
def test_everyone_has___loader__(self):
|
|
# Issue #17098: all modules should have __loader__ defined.
|
|
for name, module in sys.modules.items():
|
|
if isinstance(module, types.ModuleType):
|
|
with self.subTest(name=name):
|
|
self.assertTrue(hasattr(module, '__loader__'),
|
|
'{!r} lacks a __loader__ attribute'.format(name))
|
|
if self.machinery.BuiltinImporter.find_module(name):
|
|
self.assertIsNot(module.__loader__, None)
|
|
elif self.machinery.FrozenImporter.find_module(name):
|
|
self.assertIsNot(module.__loader__, None)
|
|
|
|
def test_everyone_has___spec__(self):
|
|
for name, module in sys.modules.items():
|
|
if isinstance(module, types.ModuleType):
|
|
with self.subTest(name=name):
|
|
self.assertTrue(hasattr(module, '__spec__'))
|
|
if self.machinery.BuiltinImporter.find_module(name):
|
|
self.assertIsNot(module.__spec__, None)
|
|
elif self.machinery.FrozenImporter.find_module(name):
|
|
self.assertIsNot(module.__spec__, None)
|
|
|
|
class Frozen_StartupTests(StartupTests, unittest.TestCase):
|
|
machinery = frozen_machinery
|
|
|
|
class Source_StartupTests(StartupTests, unittest.TestCase):
|
|
machinery = source_machinery
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|