Debian Codegraph @

Lib/test/test_importlib/test_api.py

raw
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()