Debian Codegraph @

Lib/test/test_importlib/import_/test_caching.py

raw
1 """Test that sys.modules is used properly by import."""
2 from test.test_importlib import util
3 import sys
4 from types import MethodType
5 import unittest
6 import warnings
7
8
9 class UseCache:
10
11 """When it comes to sys.modules, import prefers it over anything else.
12
13 Once a name has been resolved, sys.modules is checked to see if it contains
14 the module desired. If so, then it is returned [use cache]. If it is not
15 found, then the proper steps are taken to perform the import, but
16 sys.modules is still used to return the imported module (e.g., not what a
17 loader returns) [from cache on return]. This also applies to imports of
18 things contained within a package and thus get assigned as an attribute
19 [from cache to attribute] or pulled in thanks to a fromlist import
20 [from cache for fromlist]. But if sys.modules contains None then
21 ImportError is raised [None in cache].
22
23 """
24
25 def test_using_cache(self):
26 # [use cache]
27 module_to_use = "some module found!"
28 with util.uncache('some_module'):
29 sys.modules['some_module'] = module_to_use
30 module = self.__import__('some_module')
31 self.assertEqual(id(module_to_use), id(module))
32
33 def test_None_in_cache(self):
34 #[None in cache]
35 name = 'using_None'
36 with util.uncache(name):
37 sys.modules[name] = None
38 with self.assertRaises(ImportError) as cm:
39 self.__import__(name)
40 self.assertEqual(cm.exception.name, name)
41
42
43 (Frozen_UseCache,
44 Source_UseCache
45 ) = util.test_both(UseCache, __import__=util.__import__)
46
47
48 class ImportlibUseCache(UseCache, unittest.TestCase):
49
50 # Pertinent only to PEP 302; exec_module() doesn't return a module.
51
52 __import__ = util.__import__['Source']
53
54 def create_mock(self, *names, return_=None):
55 mock = util.mock_spec(*names)
56 original_spec = mock.find_spec
57 def find_spec(self, fullname, path, target=None):
58 return original_spec(fullname)
59 mock.find_spec = MethodType(find_spec, mock)
60 return mock
61
62 # __import__ inconsistent between loaders and built-in import when it comes
63 # to when to use the module in sys.modules and when not to.
64 def test_using_cache_after_loader(self):
65 # [from cache on return]
66 with warnings.catch_warnings():
67 warnings.simplefilter("ignore", ImportWarning)
68 with self.create_mock('module') as mock:
69 with util.import_state(meta_path=[mock]):
70 module = self.__import__('module')
71 self.assertEqual(id(module), id(sys.modules['module']))
72
73 # See test_using_cache_after_loader() for reasoning.
74 def test_using_cache_for_assigning_to_attribute(self):
75 # [from cache to attribute]
76 with warnings.catch_warnings():
77 warnings.simplefilter("ignore", ImportWarning)
78 with self.create_mock('pkg.__init__', 'pkg.module') as importer:
79 with util.import_state(meta_path=[importer]):
80 module = self.__import__('pkg.module')
81 self.assertHasAttr(module, 'module')
82 self.assertEqual(id(module.module),
83 id(sys.modules['pkg.module']))
84
85 # See test_using_cache_after_loader() for reasoning.
86 def test_using_cache_for_fromlist(self):
87 # [from cache for fromlist]
88 with self.create_mock('pkg.__init__', 'pkg.module') as importer:
89 with util.import_state(meta_path=[importer]):
90 module = self.__import__('pkg', fromlist=['module'])
91 self.assertHasAttr(module, 'module')
92 self.assertEqual(id(module.module),
93 id(sys.modules['pkg.module']))
94
95
96 if __name__ == '__main__':
97 unittest.main()