| 1 |
from test.test_importlib import util as test_util |
| 2 |
|
| 3 |
init = test_util.import_importlib('importlib') |
| 4 |
util = test_util.import_importlib('importlib.util') |
| 5 |
machinery = test_util.import_importlib('importlib.machinery') |
| 6 |
|
| 7 |
import os.path |
| 8 |
import sys |
| 9 |
from test import support |
| 10 |
from test.support import import_helper |
| 11 |
from test.support import os_helper |
| 12 |
import traceback |
| 13 |
import types |
| 14 |
import unittest |
| 15 |
|
| 16 |
|
| 17 |
class ImportModuleTests: |
| 18 |
|
| 19 |
"""Test importlib.import_module.""" |
| 20 |
|
| 21 |
def test_module_import(self): |
| 22 |
# Test importing a top-level module. |
| 23 |
with test_util.mock_spec('top_level') as mock: |
| 24 |
with test_util.import_state(meta_path=[mock]): |
| 25 |
module = self.init.import_module('top_level') |
| 26 |
self.assertEqual(module.__name__, 'top_level') |
| 27 |
|
| 28 |
def test_absolute_package_import(self): |
| 29 |
# Test importing a module from a package with an absolute name. |
| 30 |
pkg_name = 'pkg' |
| 31 |
pkg_long_name = '{0}.__init__'.format(pkg_name) |
| 32 |
name = '{0}.mod'.format(pkg_name) |
| 33 |
with test_util.mock_spec(pkg_long_name, name) as mock: |
| 34 |
with test_util.import_state(meta_path=[mock]): |
| 35 |
module = self.init.import_module(name) |
| 36 |
self.assertEqual(module.__name__, name) |
| 37 |
|
| 38 |
def test_shallow_relative_package_import(self): |
| 39 |
# Test importing a module from a package through a relative import. |
| 40 |
pkg_name = 'pkg' |
| 41 |
pkg_long_name = '{0}.__init__'.format(pkg_name) |
| 42 |
module_name = 'mod' |
| 43 |
absolute_name = '{0}.{1}'.format(pkg_name, module_name) |
| 44 |
relative_name = '.{0}'.format(module_name) |
| 45 |
with test_util.mock_spec(pkg_long_name, absolute_name) as mock: |
| 46 |
with test_util.import_state(meta_path=[mock]): |
| 47 |
self.init.import_module(pkg_name) |
| 48 |
module = self.init.import_module(relative_name, pkg_name) |
| 49 |
self.assertEqual(module.__name__, absolute_name) |
| 50 |
|
| 51 |
def test_deep_relative_package_import(self): |
| 52 |
modules = ['a.__init__', 'a.b.__init__', 'a.c'] |
| 53 |
with test_util.mock_spec(*modules) as mock: |
| 54 |
with test_util.import_state(meta_path=[mock]): |
| 55 |
self.init.import_module('a') |
| 56 |
self.init.import_module('a.b') |
| 57 |
module = self.init.import_module('..c', 'a.b') |
| 58 |
self.assertEqual(module.__name__, 'a.c') |
| 59 |
|
| 60 |
def test_absolute_import_with_package(self): |
| 61 |
# Test importing a module from a package with an absolute name with |
| 62 |
# the 'package' argument given. |
| 63 |
pkg_name = 'pkg' |
| 64 |
pkg_long_name = '{0}.__init__'.format(pkg_name) |
| 65 |
name = '{0}.mod'.format(pkg_name) |
| 66 |
with test_util.mock_spec(pkg_long_name, name) as mock: |
| 67 |
with test_util.import_state(meta_path=[mock]): |
| 68 |
self.init.import_module(pkg_name) |
| 69 |
module = self.init.import_module(name, pkg_name) |
| 70 |
self.assertEqual(module.__name__, name) |
| 71 |
|
| 72 |
def test_relative_import_wo_package(self): |
| 73 |
# Relative imports cannot happen without the 'package' argument being |
| 74 |
# set. |
| 75 |
with self.assertRaises(TypeError): |
| 76 |
self.init.import_module('.support') |
| 77 |
|
| 78 |
|
| 79 |
def test_loaded_once(self): |
| 80 |
# Issue #13591: Modules should only be loaded once when |
| 81 |
# initializing the parent package attempts to import the |
| 82 |
# module currently being imported. |
| 83 |
b_load_count = 0 |
| 84 |
def load_a(): |
| 85 |
self.init.import_module('a.b') |
| 86 |
def load_b(): |
| 87 |
nonlocal b_load_count |
| 88 |
b_load_count += 1 |
| 89 |
code = {'a': load_a, 'a.b': load_b} |
| 90 |
modules = ['a.__init__', 'a.b'] |
| 91 |
with test_util.mock_spec(*modules, module_code=code) as mock: |
| 92 |
with test_util.import_state(meta_path=[mock]): |
| 93 |
self.init.import_module('a.b') |
| 94 |
self.assertEqual(b_load_count, 1) |
| 95 |
|
| 96 |
|
| 97 |
(Frozen_ImportModuleTests, |
| 98 |
Source_ImportModuleTests |
| 99 |
) = test_util.test_both( |
| 100 |
ImportModuleTests, init=init, util=util, machinery=machinery) |
| 101 |
|
| 102 |
|
| 103 |
class FindLoaderTests: |
| 104 |
|
| 105 |
FakeMetaFinder = None |
| 106 |
|
| 107 |
def test_sys_modules(self): |
| 108 |
# If a module with __spec__.loader is in sys.modules, then return it. |
| 109 |
name = 'some_mod' |
| 110 |
with test_util.uncache(name): |
| 111 |
module = types.ModuleType(name) |
| 112 |
loader = 'a loader!' |
| 113 |
module.__spec__ = self.machinery.ModuleSpec(name, loader) |
| 114 |
sys.modules[name] = module |
| 115 |
spec = self.util.find_spec(name) |
| 116 |
self.assertIsNotNone(spec) |
| 117 |
self.assertEqual(spec.loader, loader) |
| 118 |
|
| 119 |
def test_sys_modules_loader_is_None(self): |
| 120 |
# If sys.modules[name].__spec__.loader is None, raise ValueError. |
| 121 |
name = 'some_mod' |
| 122 |
with test_util.uncache(name): |
| 123 |
module = types.ModuleType(name) |
| 124 |
module.__loader__ = None |
| 125 |
sys.modules[name] = module |
| 126 |
with self.assertRaises(ValueError): |
| 127 |
self.util.find_spec(name) |
| 128 |
|
| 129 |
def test_sys_modules_loader_is_not_set(self): |
| 130 |
# Should raise ValueError |
| 131 |
# Issue #17099 |
| 132 |
name = 'some_mod' |
| 133 |
with test_util.uncache(name): |
| 134 |
module = types.ModuleType(name) |
| 135 |
try: |
| 136 |
del module.__spec__.loader |
| 137 |
except AttributeError: |
| 138 |
pass |
| 139 |
sys.modules[name] = module |
| 140 |
with self.assertRaises(ValueError): |
| 141 |
self.util.find_spec(name) |
| 142 |
|
| 143 |
def test_success(self): |
| 144 |
# Return the loader found on sys.meta_path. |
| 145 |
name = 'some_mod' |
| 146 |
with test_util.uncache(name): |
| 147 |
with test_util.import_state(meta_path=[self.FakeMetaFinder]): |
| 148 |
spec = self.util.find_spec(name) |
| 149 |
self.assertEqual((name, (name, None)), (spec.name, spec.loader)) |
| 150 |
|
| 151 |
def test_success_path(self): |
| 152 |
# Searching on a path should work. |
| 153 |
name = 'some_mod' |
| 154 |
path = 'path to some place' |
| 155 |
with test_util.uncache(name): |
| 156 |
with test_util.import_state(meta_path=[self.FakeMetaFinder]): |
| 157 |
spec = self.util.find_spec(name, path) |
| 158 |
self.assertEqual(name, spec.name) |
| 159 |
|
| 160 |
def test_nothing(self): |
| 161 |
# None is returned upon failure to find a loader. |
| 162 |
self.assertIsNone(self.util.find_spec('nevergoingtofindthismodule')) |
| 163 |
|
| 164 |
|
| 165 |
class FindLoaderPEP451Tests(FindLoaderTests): |
| 166 |
|
| 167 |
class FakeMetaFinder: |
| 168 |
@staticmethod |
| 169 |
def find_spec(name, path=None, target=None): |
| 170 |
return machinery['Source'].ModuleSpec(name, (name, path)) |
| 171 |
|
| 172 |
|
| 173 |
(Frozen_FindLoaderPEP451Tests, |
| 174 |
Source_FindLoaderPEP451Tests |
| 175 |
) = test_util.test_both( |
| 176 |
FindLoaderPEP451Tests, init=init, util=util, machinery=machinery) |
| 177 |
|
| 178 |
|
| 179 |
class ReloadTests: |
| 180 |
|
| 181 |
def test_reload_modules(self): |
| 182 |
for mod in ('tokenize', 'time', 'marshal'): |
| 183 |
with self.subTest(module=mod): |
| 184 |
with import_helper.CleanImport(mod): |
| 185 |
module = self.init.import_module(mod) |
| 186 |
self.init.reload(module) |
| 187 |
|
| 188 |
def test_module_replaced(self): |
| 189 |
def code(): |
| 190 |
import sys |
| 191 |
module = type(sys)('top_level') |
| 192 |
module.spam = 3 |
| 193 |
sys.modules['top_level'] = module |
| 194 |
mock = test_util.mock_spec('top_level', |
| 195 |
module_code={'top_level': code}) |
| 196 |
with mock: |
| 197 |
with test_util.import_state(meta_path=[mock]): |
| 198 |
module = self.init.import_module('top_level') |
| 199 |
reloaded = self.init.reload(module) |
| 200 |
actual = sys.modules['top_level'] |
| 201 |
self.assertEqual(actual.spam, 3) |
| 202 |
self.assertEqual(reloaded.spam, 3) |
| 203 |
|
| 204 |
def test_reload_missing_loader(self): |
| 205 |
with import_helper.CleanImport('types'): |
| 206 |
import types |
| 207 |
loader = types.__loader__ |
| 208 |
del types.__loader__ |
| 209 |
reloaded = self.init.reload(types) |
| 210 |
|
| 211 |
self.assertIs(reloaded, types) |
| 212 |
self.assertIs(sys.modules['types'], types) |
| 213 |
self.assertEqual(reloaded.__loader__.path, loader.path) |
| 214 |
|
| 215 |
def test_reload_loader_replaced(self): |
| 216 |
with import_helper.CleanImport('types'): |
| 217 |
import types |
| 218 |
types.__loader__ = None |
| 219 |
self.init.invalidate_caches() |
| 220 |
reloaded = self.init.reload(types) |
| 221 |
|
| 222 |
self.assertIsNot(reloaded.__loader__, None) |
| 223 |
self.assertIs(reloaded, types) |
| 224 |
self.assertIs(sys.modules['types'], types) |
| 225 |
|
| 226 |
def test_reload_location_changed(self): |
| 227 |
name = 'spam' |
| 228 |
with os_helper.temp_cwd(None) as cwd: |
| 229 |
with test_util.uncache('spam'): |
| 230 |
with import_helper.DirsOnSysPath(cwd): |
| 231 |
# Start as a plain module. |
| 232 |
self.init.invalidate_caches() |
| 233 |
path = os.path.join(cwd, name + '.py') |
| 234 |
cached = self.util.cache_from_source(path) |
| 235 |
expected = {'__name__': name, |
| 236 |
'__package__': '', |
| 237 |
'__file__': path, |
| 238 |
'__cached__': cached, |
| 239 |
'__doc__': None, |
| 240 |
} |
| 241 |
os_helper.create_empty_file(path) |
| 242 |
module = self.init.import_module(name) |
| 243 |
ns = vars(module).copy() |
| 244 |
loader = ns.pop('__loader__') |
| 245 |
spec = ns.pop('__spec__') |
| 246 |
ns.pop('__builtins__', None) # An implementation detail. |
| 247 |
self.assertEqual(spec.name, name) |
| 248 |
self.assertEqual(spec.loader, loader) |
| 249 |
self.assertEqual(loader.path, path) |
| 250 |
self.assertEqual(ns, expected) |
| 251 |
|
| 252 |
# Change to a package. |
| 253 |
self.init.invalidate_caches() |
| 254 |
init_path = os.path.join(cwd, name, '__init__.py') |
| 255 |
cached = self.util.cache_from_source(init_path) |
| 256 |
expected = {'__name__': name, |
| 257 |
'__package__': name, |
| 258 |
'__file__': init_path, |
| 259 |
'__cached__': cached, |
| 260 |
'__path__': [os.path.dirname(init_path)], |
| 261 |
'__doc__': None, |
| 262 |
} |
| 263 |
os.mkdir(name) |
| 264 |
os.rename(path, init_path) |
| 265 |
reloaded = self.init.reload(module) |
| 266 |
ns = vars(reloaded).copy() |
| 267 |
loader = ns.pop('__loader__') |
| 268 |
spec = ns.pop('__spec__') |
| 269 |
ns.pop('__builtins__', None) # An implementation detail. |
| 270 |
self.assertEqual(spec.name, name) |
| 271 |
self.assertEqual(spec.loader, loader) |
| 272 |
self.assertIs(reloaded, module) |
| 273 |
self.assertEqual(loader.path, init_path) |
| 274 |
self.maxDiff = None |
| 275 |
self.assertEqual(ns, expected) |
| 276 |
|
| 277 |
def test_reload_namespace_changed(self): |
| 278 |
name = 'spam' |
| 279 |
with os_helper.temp_cwd(None) as cwd: |
| 280 |
with test_util.uncache('spam'): |
| 281 |
with test_util.import_state(path=[cwd]): |
| 282 |
self.init._bootstrap_external._install(self.init._bootstrap) |
| 283 |
# Start as a namespace package. |
| 284 |
self.init.invalidate_caches() |
| 285 |
bad_path = os.path.join(cwd, name, '__init.py') |
| 286 |
cached = self.util.cache_from_source(bad_path) |
| 287 |
expected = {'__name__': name, |
| 288 |
'__package__': name, |
| 289 |
'__doc__': None, |
| 290 |
'__file__': None, |
| 291 |
} |
| 292 |
os.mkdir(name) |
| 293 |
with open(bad_path, 'w', encoding='utf-8') as init_file: |
| 294 |
init_file.write('eggs = None') |
| 295 |
module = self.init.import_module(name) |
| 296 |
ns = vars(module).copy() |
| 297 |
loader = ns.pop('__loader__') |
| 298 |
path = ns.pop('__path__') |
| 299 |
spec = ns.pop('__spec__') |
| 300 |
ns.pop('__builtins__', None) # An implementation detail. |
| 301 |
self.assertEqual(spec.name, name) |
| 302 |
self.assertIsNotNone(spec.loader) |
| 303 |
self.assertIsNotNone(loader) |
| 304 |
self.assertEqual(spec.loader, loader) |
| 305 |
self.assertEqual(set(path), |
| 306 |
set([os.path.dirname(bad_path)])) |
| 307 |
with self.assertRaises(AttributeError): |
| 308 |
# a NamespaceLoader |
| 309 |
loader.path |
| 310 |
self.assertEqual(ns, expected) |
| 311 |
|
| 312 |
# Change to a regular package. |
| 313 |
self.init.invalidate_caches() |
| 314 |
init_path = os.path.join(cwd, name, '__init__.py') |
| 315 |
cached = self.util.cache_from_source(init_path) |
| 316 |
expected = {'__name__': name, |
| 317 |
'__package__': name, |
| 318 |
'__file__': init_path, |
| 319 |
'__cached__': cached, |
| 320 |
'__path__': [os.path.dirname(init_path)], |
| 321 |
'__doc__': None, |
| 322 |
'eggs': None, |
| 323 |
} |
| 324 |
os.rename(bad_path, init_path) |
| 325 |
reloaded = self.init.reload(module) |
| 326 |
ns = vars(reloaded).copy() |
| 327 |
loader = ns.pop('__loader__') |
| 328 |
spec = ns.pop('__spec__') |
| 329 |
ns.pop('__builtins__', None) # An implementation detail. |
| 330 |
self.assertEqual(spec.name, name) |
| 331 |
self.assertEqual(spec.loader, loader) |
| 332 |
self.assertIs(reloaded, module) |
| 333 |
self.assertEqual(loader.path, init_path) |
| 334 |
self.assertEqual(ns, expected) |
| 335 |
|
| 336 |
def test_reload_submodule(self): |
| 337 |
# See #19851. |
| 338 |
name = 'spam' |
| 339 |
subname = 'ham' |
| 340 |
with test_util.temp_module(name, pkg=True) as pkg_dir: |
| 341 |
fullname, _ = test_util.submodule(name, subname, pkg_dir) |
| 342 |
ham = self.init.import_module(fullname) |
| 343 |
reloaded = self.init.reload(ham) |
| 344 |
self.assertIs(reloaded, ham) |
| 345 |
|
| 346 |
def test_module_missing_spec(self): |
| 347 |
#Test that reload() throws ModuleNotFounderror when reloading |
| 348 |
# a module whose missing a spec. (bpo-29851) |
| 349 |
name = 'spam' |
| 350 |
with test_util.uncache(name): |
| 351 |
module = sys.modules[name] = types.ModuleType(name) |
| 352 |
# Sanity check by attempting an import. |
| 353 |
module = self.init.import_module(name) |
| 354 |
self.assertIsNone(module.__spec__) |
| 355 |
with self.assertRaises(ModuleNotFoundError): |
| 356 |
self.init.reload(module) |
| 357 |
|
| 358 |
def test_reload_traceback_with_non_str(self): |
| 359 |
# gh-125519 |
| 360 |
with support.captured_stdout() as stdout: |
| 361 |
try: |
| 362 |
self.init.reload("typing") |
| 363 |
except TypeError as exc: |
| 364 |
traceback.print_exception(exc, file=stdout) |
| 365 |
else: |
| 366 |
self.fail("Expected TypeError to be raised") |
| 367 |
printed_traceback = stdout.getvalue() |
| 368 |
self.assertIn("TypeError", printed_traceback) |
| 369 |
self.assertNotIn("AttributeError", printed_traceback) |
| 370 |
self.assertNotIn("module.__spec__.name", printed_traceback) |
| 371 |
|
| 372 |
|
| 373 |
(Frozen_ReloadTests, |
| 374 |
Source_ReloadTests |
| 375 |
) = test_util.test_both( |
| 376 |
ReloadTests, init=init, util=util, machinery=machinery) |
| 377 |
|
| 378 |
|
| 379 |
class InvalidateCacheTests: |
| 380 |
|
| 381 |
def test_method_called(self): |
| 382 |
# If defined the method should be called. |
| 383 |
class InvalidatingNullFinder: |
| 384 |
def __init__(self, *ignored): |
| 385 |
self.called = False |
| 386 |
def invalidate_caches(self): |
| 387 |
self.called = True |
| 388 |
|
| 389 |
key = os.path.abspath('gobledeegook') |
| 390 |
meta_ins = InvalidatingNullFinder() |
| 391 |
path_ins = InvalidatingNullFinder() |
| 392 |
sys.meta_path.insert(0, meta_ins) |
| 393 |
self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key)) |
| 394 |
sys.path_importer_cache[key] = path_ins |
| 395 |
self.addCleanup(lambda: sys.meta_path.remove(meta_ins)) |
| 396 |
self.init.invalidate_caches() |
| 397 |
self.assertTrue(meta_ins.called) |
| 398 |
self.assertTrue(path_ins.called) |
| 399 |
|
| 400 |
def test_method_lacking(self): |
| 401 |
# There should be no issues if the method is not defined. |
| 402 |
key = 'gobbledeegook' |
| 403 |
sys.path_importer_cache[key] = None |
| 404 |
self.addCleanup(lambda: sys.path_importer_cache.pop(key, None)) |
| 405 |
self.init.invalidate_caches() # Shouldn't trigger an exception. |
| 406 |
|
| 407 |
|
| 408 |
(Frozen_InvalidateCacheTests, |
| 409 |
Source_InvalidateCacheTests |
| 410 |
) = test_util.test_both( |
| 411 |
InvalidateCacheTests, init=init, util=util, machinery=machinery) |
| 412 |
|
| 413 |
|
| 414 |
class FrozenImportlibTests(unittest.TestCase): |
| 415 |
|
| 416 |
def test_no_frozen_importlib(self): |
| 417 |
# Should be able to import w/o _frozen_importlib being defined. |
| 418 |
# Can't do an isinstance() check since separate copies of importlib |
| 419 |
# may have been used for import, so just check the name is not for the |
| 420 |
# frozen loader. |
| 421 |
source_init = init['Source'] |
| 422 |
self.assertNotEqual(source_init.__loader__.__class__.__name__, |
| 423 |
'FrozenImporter') |
| 424 |
|
| 425 |
|
| 426 |
class StartupTests: |
| 427 |
|
| 428 |
def test_everyone_has___loader__(self): |
| 429 |
# Issue #17098: all modules should have __loader__ defined. |
| 430 |
for name, module in sys.modules.items(): |
| 431 |
if isinstance(module, types.ModuleType): |
| 432 |
with self.subTest(name=name): |
| 433 |
self.assertHasAttr(module, '__loader__') |
| 434 |
if self.machinery.BuiltinImporter.find_spec(name): |
| 435 |
self.assertIsNot(module.__loader__, None) |
| 436 |
elif self.machinery.FrozenImporter.find_spec(name): |
| 437 |
self.assertIsNot(module.__loader__, None) |
| 438 |
|
| 439 |
def test_everyone_has___spec__(self): |
| 440 |
for name, module in sys.modules.items(): |
| 441 |
if isinstance(module, types.ModuleType): |
| 442 |
with self.subTest(name=name): |
| 443 |
self.assertHasAttr(module, '__spec__') |
| 444 |
if self.machinery.BuiltinImporter.find_spec(name): |
| 445 |
self.assertIsNot(module.__spec__, None) |
| 446 |
elif self.machinery.FrozenImporter.find_spec(name): |
| 447 |
self.assertIsNot(module.__spec__, None) |
| 448 |
|
| 449 |
|
| 450 |
(Frozen_StartupTests, |
| 451 |
Source_StartupTests |
| 452 |
) = test_util.test_both(StartupTests, machinery=machinery) |
| 453 |
|
| 454 |
|
| 455 |
class TestModuleAll(unittest.TestCase): |
| 456 |
def test_machinery(self): |
| 457 |
extra = ( |
| 458 |
# from importlib._bootstrap and importlib._bootstrap_external |
| 459 |
'AppleFrameworkLoader', |
| 460 |
'BYTECODE_SUFFIXES', |
| 461 |
'BuiltinImporter', |
| 462 |
'DEBUG_BYTECODE_SUFFIXES', |
| 463 |
'EXTENSION_SUFFIXES', |
| 464 |
'ExtensionFileLoader', |
| 465 |
'FileFinder', |
| 466 |
'FrozenImporter', |
| 467 |
'ModuleSpec', |
| 468 |
'NamespaceLoader', |
| 469 |
'OPTIMIZED_BYTECODE_SUFFIXES', |
| 470 |
'PathFinder', |
| 471 |
'SOURCE_SUFFIXES', |
| 472 |
'SourceFileLoader', |
| 473 |
'SourcelessFileLoader', |
| 474 |
'WindowsRegistryFinder', |
| 475 |
) |
| 476 |
support.check__all__(self, machinery['Source'], extra=extra) |
| 477 |
|
| 478 |
def test_util(self): |
| 479 |
extra = ( |
| 480 |
# from importlib.abc, importlib._bootstrap |
| 481 |
# and importlib._bootstrap_external |
| 482 |
'Loader', |
| 483 |
'MAGIC_NUMBER', |
| 484 |
'cache_from_source', |
| 485 |
'decode_source', |
| 486 |
'module_from_spec', |
| 487 |
'source_from_cache', |
| 488 |
'spec_from_file_location', |
| 489 |
'spec_from_loader', |
| 490 |
) |
| 491 |
support.check__all__(self, util['Source'], extra=extra) |
| 492 |
|
| 493 |
|
| 494 |
class TestDeprecations(unittest.TestCase): |
| 495 |
def test_machinery_deprecated_attributes(self): |
| 496 |
from importlib import machinery |
| 497 |
attributes = ( |
| 498 |
'DEBUG_BYTECODE_SUFFIXES', |
| 499 |
'OPTIMIZED_BYTECODE_SUFFIXES', |
| 500 |
) |
| 501 |
for attr in attributes: |
| 502 |
with self.subTest(attr=attr): |
| 503 |
with self.assertWarns(DeprecationWarning): |
| 504 |
getattr(machinery, attr) |
| 505 |
|
| 506 |
|
| 507 |
if __name__ == '__main__': |
| 508 |
unittest.main() |