Python code coverage for Lib/importlib/test/test_api.py

#	count	content
1	n/a	from . import util
2	n/a	import imp
3	n/a	import importlib
4	n/a	from importlib import machinery
5	n/a	import sys
6	n/a	from test import support
7	n/a	import unittest
8	n/a
9	n/a
10	n/a	class ImportModuleTests(unittest.TestCase):
11	n/a
12	n/a	"""Test importlib.import_module."""
13	n/a
14	n/a	def test_module_import(self):
15	n/a	# Test importing a top-level module.
16	n/a	with util.mock_modules('top_level') as mock:
17	n/a	with util.import_state(meta_path=[mock]):
18	n/a	module = importlib.import_module('top_level')
19	n/a	self.assertEqual(module.__name__, 'top_level')
20	n/a
21	n/a	def test_absolute_package_import(self):
22	n/a	# Test importing a module from a package with an absolute name.
23	n/a	pkg_name = 'pkg'
24	n/a	pkg_long_name = '{0}.__init__'.format(pkg_name)
25	n/a	name = '{0}.mod'.format(pkg_name)
26	n/a	with util.mock_modules(pkg_long_name, name) as mock:
27	n/a	with util.import_state(meta_path=[mock]):
28	n/a	module = importlib.import_module(name)
29	n/a	self.assertEqual(module.__name__, name)
30	n/a
31	n/a	def test_shallow_relative_package_import(self):
32	n/a	# Test importing a module from a package through a relative import.
33	n/a	pkg_name = 'pkg'
34	n/a	pkg_long_name = '{0}.__init__'.format(pkg_name)
35	n/a	module_name = 'mod'
36	n/a	absolute_name = '{0}.{1}'.format(pkg_name, module_name)
37	n/a	relative_name = '.{0}'.format(module_name)
38	n/a	with util.mock_modules(pkg_long_name, absolute_name) as mock:
39	n/a	with util.import_state(meta_path=[mock]):
40	n/a	importlib.import_module(pkg_name)
41	n/a	module = importlib.import_module(relative_name, pkg_name)
42	n/a	self.assertEqual(module.__name__, absolute_name)
43	n/a
44	n/a	def test_deep_relative_package_import(self):
45	n/a	modules = ['a.__init__', 'a.b.__init__', 'a.c']
46	n/a	with util.mock_modules(*modules) as mock:
47	n/a	with util.import_state(meta_path=[mock]):
48	n/a	importlib.import_module('a')
49	n/a	importlib.import_module('a.b')
50	n/a	module = importlib.import_module('..c', 'a.b')
51	n/a	self.assertEqual(module.__name__, 'a.c')
52	n/a
53	n/a	def test_absolute_import_with_package(self):
54	n/a	# Test importing a module from a package with an absolute name with
55	n/a	# the 'package' argument given.
56	n/a	pkg_name = 'pkg'
57	n/a	pkg_long_name = '{0}.__init__'.format(pkg_name)
58	n/a	name = '{0}.mod'.format(pkg_name)
59	n/a	with util.mock_modules(pkg_long_name, name) as mock:
60	n/a	with util.import_state(meta_path=[mock]):
61	n/a	importlib.import_module(pkg_name)
62	n/a	module = importlib.import_module(name, pkg_name)
63	n/a	self.assertEqual(module.__name__, name)
64	n/a
65	n/a	def test_relative_import_wo_package(self):
66	n/a	# Relative imports cannot happen without the 'package' argument being
67	n/a	# set.
68	n/a	with self.assertRaises(TypeError):
69	n/a	importlib.import_module('.support')
70	n/a
71	n/a
72	n/a	def test_loaded_once(self):
73	n/a	# Issue #13591: Modules should only be loaded once when
74	n/a	# initializing the parent package attempts to import the
75	n/a	# module currently being imported.
76	n/a	b_load_count = 0
77	n/a	def load_a():
78	n/a	importlib.import_module('a.b')
79	n/a	def load_b():
80	n/a	nonlocal b_load_count
81	n/a	b_load_count += 1
82	n/a	code = {'a': load_a, 'a.b': load_b}
83	n/a	modules = ['a.__init__', 'a.b']
84	n/a	with util.mock_modules(*modules, module_code=code) as mock:
85	n/a	with util.import_state(meta_path=[mock]):
86	n/a	importlib.import_module('a.b')
87	n/a	self.assertEqual(b_load_count, 1)
88	n/a
89	n/a
90	n/a	class FindLoaderTests(unittest.TestCase):
91	n/a
92	n/a	class FakeMetaFinder:
93	n/a	@staticmethod
94	n/a	def find_module(name, path=None): return name, path
95	n/a
96	n/a	def test_sys_modules(self):
97	n/a	# If a module with __loader__ is in sys.modules, then return it.
98	n/a	name = 'some_mod'
99	n/a	with util.uncache(name):
100	n/a	module = imp.new_module(name)
101	n/a	loader = 'a loader!'
102	n/a	module.__loader__ = loader
103	n/a	sys.modules[name] = module
104	n/a	found = importlib.find_loader(name)
105	n/a	self.assertEqual(loader, found)
106	n/a
107	n/a	def test_sys_modules_loader_is_None(self):
108	n/a	# If sys.modules[name].__loader__ is None, raise ValueError.
109	n/a	name = 'some_mod'
110	n/a	with util.uncache(name):
111	n/a	module = imp.new_module(name)
112	n/a	module.__loader__ = None
113	n/a	sys.modules[name] = module
114	n/a	with self.assertRaises(ValueError):
115	n/a	importlib.find_loader(name)
116	n/a
117	n/a	def test_success(self):
118	n/a	# Return the loader found on sys.meta_path.
119	n/a	name = 'some_mod'
120	n/a	with util.uncache(name):
121	n/a	with util.import_state(meta_path=[self.FakeMetaFinder]):
122	n/a	self.assertEqual((name, None), importlib.find_loader(name))
123	n/a
124	n/a	def test_success_path(self):
125	n/a	# Searching on a path should work.
126	n/a	name = 'some_mod'
127	n/a	path = 'path to some place'
128	n/a	with util.uncache(name):
129	n/a	with util.import_state(meta_path=[self.FakeMetaFinder]):
130	n/a	self.assertEqual((name, path),
131	n/a	importlib.find_loader(name, path))
132	n/a
133	n/a	def test_nothing(self):
134	n/a	# None is returned upon failure to find a loader.
135	n/a	self.assertIsNone(importlib.find_loader('nevergoingtofindthismodule'))
136	n/a
137	n/a
138	n/a	class InvalidateCacheTests(unittest.TestCase):
139	n/a
140	n/a	def test_method_called(self):
141	n/a	# If defined the method should be called.
142	n/a	class InvalidatingNullFinder:
143	n/a	def __init__(self, *ignored):
144	n/a	self.called = False
145	n/a	def find_module(self, *args):
146	n/a	return None
147	n/a	def invalidate_caches(self):
148	n/a	self.called = True
149	n/a
150	n/a	key = 'gobledeegook'
151	n/a	ins = InvalidatingNullFinder()
152	n/a	sys.path_importer_cache[key] = ins
153	n/a	self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key))
154	n/a	importlib.invalidate_caches()
155	n/a	self.assertTrue(ins.called)
156	n/a
157	n/a	def test_method_lacking(self):
158	n/a	# There should be no issues if the method is not defined.
159	n/a	key = 'gobbledeegook'
160	n/a	sys.path_importer_cache[key] = imp.NullImporter('abc')
161	n/a	self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key))
162	n/a	importlib.invalidate_caches() # Shouldn't trigger an exception.
163	n/a
164	n/a
165	n/a	class FrozenImportlibTests(unittest.TestCase):
166	n/a
167	n/a	def test_no_frozen_importlib(self):
168	n/a	# Should be able to import w/o _frozen_importlib being defined.
169	n/a	module = support.import_fresh_module('importlib', blocked=['_frozen_importlib'])
170	n/a	self.assertFalse(isinstance(module.__loader__,
171	n/a	machinery.FrozenImporter))
172	n/a
173	n/a
174	n/a	def test_main():
175	n/a	from test.support import run_unittest
176	n/a	run_unittest(ImportModuleTests,
177	n/a	FindLoaderTests,
178	n/a	InvalidateCacheTests,
179	n/a	FrozenImportlibTests)
180	n/a
181	n/a
182	n/a	if __name__ == '__main__':
183	n/a	test_main()