Python code coverage for Lib/importlib/test/import_/test_relative_imports.py

#	count	content
1	n/a	"""Test relative imports (PEP 328)."""
2	n/a	from .. import util
3	n/a	from . import util as import_util
4	n/a	import sys
5	n/a	import unittest
6	n/a
7	n/a	class RelativeImports(unittest.TestCase):
8	n/a
9	n/a	"""PEP 328 introduced relative imports. This allows for imports to occur
10	n/a	from within a package without having to specify the actual package name.
11	n/a
12	n/a	A simple example is to import another module within the same package
13	n/a	[module from module]::
14	n/a
15	n/a	# From pkg.mod1 with pkg.mod2 being a module.
16	n/a	from . import mod2
17	n/a
18	n/a	This also works for getting an attribute from a module that is specified
19	n/a	in a relative fashion [attr from module]::
20	n/a
21	n/a	# From pkg.mod1.
22	n/a	from .mod2 import attr
23	n/a
24	n/a	But this is in no way restricted to working between modules; it works
25	n/a	from [package to module],::
26	n/a
27	n/a	# From pkg, importing pkg.module which is a module.
28	n/a	from . import module
29	n/a
30	n/a	[module to package],::
31	n/a
32	n/a	# Pull attr from pkg, called from pkg.module which is a module.
33	n/a	from . import attr
34	n/a
35	n/a	and [package to package]::
36	n/a
37	n/a	# From pkg.subpkg1 (both pkg.subpkg[1,2] are packages).
38	n/a	from .. import subpkg2
39	n/a
40	n/a	The number of dots used is in no way restricted [deep import]::
41	n/a
42	n/a	# Import pkg.attr from pkg.pkg1.pkg2.pkg3.pkg4.pkg5.
43	n/a	from ...... import attr
44	n/a
45	n/a	To prevent someone from accessing code that is outside of a package, one
46	n/a	cannot reach the location containing the root package itself::
47	n/a
48	n/a	# From pkg.__init__ [too high from package]
49	n/a	from .. import top_level
50	n/a
51	n/a	# From pkg.module [too high from module]
52	n/a	from .. import top_level
53	n/a
54	n/a	Relative imports are the only type of import that allow for an empty
55	n/a	module name for an import [empty name].
56	n/a
57	n/a	"""
58	n/a
59	n/a	def relative_import_test(self, create, globals_, callback):
60	n/a	"""Abstract out boilerplace for setting up for an import test."""
61	n/a	uncache_names = []
62	n/a	for name in create:
63	n/a	if not name.endswith('.__init__'):
64	n/a	uncache_names.append(name)
65	n/a	else:
66	n/a	uncache_names.append(name[:-len('.__init__')])
67	n/a	with util.mock_modules(*create) as importer:
68	n/a	with util.import_state(meta_path=[importer]):
69	n/a	for global_ in globals_:
70	n/a	with util.uncache(*uncache_names):
71	n/a	callback(global_)
72	n/a
73	n/a
74	n/a	def test_module_from_module(self):
75	n/a	# [module from module]
76	n/a	create = 'pkg.__init__', 'pkg.mod2'
77	n/a	globals_ = {'__package__': 'pkg'}, {'__name__': 'pkg.mod1'}
78	n/a	def callback(global_):
79	n/a	import_util.import_('pkg') # For __import__().
80	n/a	module = import_util.import_('', global_, fromlist=['mod2'], level=1)
81	n/a	self.assertEqual(module.__name__, 'pkg')
82	n/a	self.assertTrue(hasattr(module, 'mod2'))
83	n/a	self.assertEqual(module.mod2.attr, 'pkg.mod2')
84	n/a	self.relative_import_test(create, globals_, callback)
85	n/a
86	n/a	def test_attr_from_module(self):
87	n/a	# [attr from module]
88	n/a	create = 'pkg.__init__', 'pkg.mod2'
89	n/a	globals_ = {'__package__': 'pkg'}, {'__name__': 'pkg.mod1'}
90	n/a	def callback(global_):
91	n/a	import_util.import_('pkg') # For __import__().
92	n/a	module = import_util.import_('mod2', global_, fromlist=['attr'],
93	n/a	level=1)
94	n/a	self.assertEqual(module.__name__, 'pkg.mod2')
95	n/a	self.assertEqual(module.attr, 'pkg.mod2')
96	n/a	self.relative_import_test(create, globals_, callback)
97	n/a
98	n/a	def test_package_to_module(self):
99	n/a	# [package to module]
100	n/a	create = 'pkg.__init__', 'pkg.module'
101	n/a	globals_ = ({'__package__': 'pkg'},
102	n/a	{'__name__': 'pkg', '__path__': ['blah']})
103	n/a	def callback(global_):
104	n/a	import_util.import_('pkg') # For __import__().
105	n/a	module = import_util.import_('', global_, fromlist=['module'],
106	n/a	level=1)
107	n/a	self.assertEqual(module.__name__, 'pkg')
108	n/a	self.assertTrue(hasattr(module, 'module'))
109	n/a	self.assertEqual(module.module.attr, 'pkg.module')
110	n/a	self.relative_import_test(create, globals_, callback)
111	n/a
112	n/a	def test_module_to_package(self):
113	n/a	# [module to package]
114	n/a	create = 'pkg.__init__', 'pkg.module'
115	n/a	globals_ = {'__package__': 'pkg'}, {'__name__': 'pkg.module'}
116	n/a	def callback(global_):
117	n/a	import_util.import_('pkg') # For __import__().
118	n/a	module = import_util.import_('', global_, fromlist=['attr'], level=1)
119	n/a	self.assertEqual(module.__name__, 'pkg')
120	n/a	self.relative_import_test(create, globals_, callback)
121	n/a
122	n/a	def test_package_to_package(self):
123	n/a	# [package to package]
124	n/a	create = ('pkg.__init__', 'pkg.subpkg1.__init__',
125	n/a	'pkg.subpkg2.__init__')
126	n/a	globals_ = ({'__package__': 'pkg.subpkg1'},
127	n/a	{'__name__': 'pkg.subpkg1', '__path__': ['blah']})
128	n/a	def callback(global_):
129	n/a	module = import_util.import_('', global_, fromlist=['subpkg2'],
130	n/a	level=2)
131	n/a	self.assertEqual(module.__name__, 'pkg')
132	n/a	self.assertTrue(hasattr(module, 'subpkg2'))
133	n/a	self.assertEqual(module.subpkg2.attr, 'pkg.subpkg2.__init__')
134	n/a
135	n/a	def test_deep_import(self):
136	n/a	# [deep import]
137	n/a	create = ['pkg.__init__']
138	n/a	for count in range(1,6):
139	n/a	create.append('{0}.pkg{1}.__init__'.format(
140	n/a	create[-1][:-len('.__init__')], count))
141	n/a	globals_ = ({'__package__': 'pkg.pkg1.pkg2.pkg3.pkg4.pkg5'},
142	n/a	{'__name__': 'pkg.pkg1.pkg2.pkg3.pkg4.pkg5',
143	n/a	'__path__': ['blah']})
144	n/a	def callback(global_):
145	n/a	import_util.import_(globals_[0]['__package__'])
146	n/a	module = import_util.import_('', global_, fromlist=['attr'], level=6)
147	n/a	self.assertEqual(module.__name__, 'pkg')
148	n/a	self.relative_import_test(create, globals_, callback)
149	n/a
150	n/a	def test_too_high_from_package(self):
151	n/a	# [too high from package]
152	n/a	create = ['top_level', 'pkg.__init__']
153	n/a	globals_ = ({'__package__': 'pkg'},
154	n/a	{'__name__': 'pkg', '__path__': ['blah']})
155	n/a	def callback(global_):
156	n/a	import_util.import_('pkg')
157	n/a	with self.assertRaises(ValueError):
158	n/a	import_util.import_('', global_, fromlist=['top_level'],
159	n/a	level=2)
160	n/a	self.relative_import_test(create, globals_, callback)
161	n/a
162	n/a	def test_too_high_from_module(self):
163	n/a	# [too high from module]
164	n/a	create = ['top_level', 'pkg.__init__', 'pkg.module']
165	n/a	globals_ = {'__package__': 'pkg'}, {'__name__': 'pkg.module'}
166	n/a	def callback(global_):
167	n/a	import_util.import_('pkg')
168	n/a	with self.assertRaises(ValueError):
169	n/a	import_util.import_('', global_, fromlist=['top_level'],
170	n/a	level=2)
171	n/a	self.relative_import_test(create, globals_, callback)
172	n/a
173	n/a	def test_empty_name_w_level_0(self):
174	n/a	# [empty name]
175	n/a	with self.assertRaises(ValueError):
176	n/a	import_util.import_('')
177	n/a
178	n/a	def test_import_from_different_package(self):
179	n/a	# Test importing from a different package than the caller.
180	n/a	# in pkg.subpkg1.mod
181	n/a	# from ..subpkg2 import mod
182	n/a	create = ['__runpy_pkg__.__init__',
183	n/a	'__runpy_pkg__.__runpy_pkg__.__init__',
184	n/a	'__runpy_pkg__.uncle.__init__',
185	n/a	'__runpy_pkg__.uncle.cousin.__init__',
186	n/a	'__runpy_pkg__.uncle.cousin.nephew']
187	n/a	globals_ = {'__package__': '__runpy_pkg__.__runpy_pkg__'}
188	n/a	def callback(global_):
189	n/a	import_util.import_('__runpy_pkg__.__runpy_pkg__')
190	n/a	module = import_util.import_('uncle.cousin', globals_, {},
191	n/a	fromlist=['nephew'],
192	n/a	level=2)
193	n/a	self.assertEqual(module.__name__, '__runpy_pkg__.uncle.cousin')
194	n/a	self.relative_import_test(create, globals_, callback)
195	n/a
196	n/a	def test_import_relative_import_no_fromlist(self):
197	n/a	# Import a relative module w/ no fromlist.
198	n/a	create = ['crash.__init__', 'crash.mod']
199	n/a	globals_ = [{'__package__': 'crash', '__name__': 'crash'}]
200	n/a	def callback(global_):
201	n/a	import_util.import_('crash')
202	n/a	mod = import_util.import_('mod', global_, {}, [], 1)
203	n/a	self.assertEqual(mod.__name__, 'crash.mod')
204	n/a	self.relative_import_test(create, globals_, callback)
205	n/a
206	n/a	def test_relative_import_no_globals(self):
207	n/a	# No globals for a relative import is an error.
208	n/a	with self.assertRaises(KeyError):
209	n/a	import_util.import_('sys', level=1)
210	n/a
211	n/a
212	n/a	def test_main():
213	n/a	from test.support import run_unittest
214	n/a	run_unittest(RelativeImports)
215	n/a
216	n/a	if __name__ == '__main__':
217	n/a	test_main()