Python code coverage for Lib/importlib/test/source/test_file_loader.py

#	count	content
1	n/a	from ... import _bootstrap
2	n/a	import importlib
3	n/a	import importlib.abc
4	n/a	from .. import abc
5	n/a	from .. import util
6	n/a	from . import util as source_util
7	n/a
8	n/a	import errno
9	n/a	import imp
10	n/a	import marshal
11	n/a	import os
12	n/a	import py_compile
13	n/a	import shutil
14	n/a	import stat
15	n/a	import sys
16	n/a	import unittest
17	n/a
18	n/a	from test.support import make_legacy_pyc
19	n/a
20	n/a
21	n/a	class SimpleTest(unittest.TestCase):
22	n/a
23	n/a	"""Should have no issue importing a source module [basic]. And if there is
24	n/a	a syntax error, it should raise a SyntaxError [syntax error].
25	n/a
26	n/a	"""
27	n/a
28	n/a	def test_load_module_API(self):
29	n/a	# If fullname is not specified that assume self.name is desired.
30	n/a	class TesterMixin(importlib.abc.Loader):
31	n/a	def load_module(self, fullname): return fullname
32	n/a
33	n/a	class Tester(importlib.abc.FileLoader, TesterMixin):
34	n/a	def get_code(self, _): pass
35	n/a	def get_source(self, _): pass
36	n/a	def is_package(self, _): pass
37	n/a
38	n/a	name = 'mod_name'
39	n/a	loader = Tester(name, 'some_path')
40	n/a	self.assertEqual(name, loader.load_module())
41	n/a	self.assertEqual(name, loader.load_module(None))
42	n/a	self.assertEqual(name, loader.load_module(name))
43	n/a	with self.assertRaises(ImportError):
44	n/a	loader.load_module(loader.name + 'XXX')
45	n/a
46	n/a	def test_get_filename_API(self):
47	n/a	# If fullname is not set then assume self.path is desired.
48	n/a	class Tester(importlib.abc.FileLoader):
49	n/a	def get_code(self, _): pass
50	n/a	def get_source(self, _): pass
51	n/a	def is_package(self, _): pass
52	n/a
53	n/a	path = 'some_path'
54	n/a	name = 'some_name'
55	n/a	loader = Tester(name, path)
56	n/a	self.assertEqual(path, loader.get_filename(name))
57	n/a	self.assertEqual(path, loader.get_filename())
58	n/a	self.assertEqual(path, loader.get_filename(None))
59	n/a	with self.assertRaises(ImportError):
60	n/a	loader.get_filename(name + 'XXX')
61	n/a
62	n/a	# [basic]
63	n/a	def test_module(self):
64	n/a	with source_util.create_modules('_temp') as mapping:
65	n/a	loader = _bootstrap.SourceFileLoader('_temp', mapping['_temp'])
66	n/a	module = loader.load_module('_temp')
67	n/a	self.assertIn('_temp', sys.modules)
68	n/a	check = {'__name__': '_temp', '__file__': mapping['_temp'],
69	n/a	'__package__': ''}
70	n/a	for attr, value in check.items():
71	n/a	self.assertEqual(getattr(module, attr), value)
72	n/a
73	n/a	def test_package(self):
74	n/a	with source_util.create_modules('_pkg.__init__') as mapping:
75	n/a	loader = _bootstrap.SourceFileLoader('_pkg',
76	n/a	mapping['_pkg.__init__'])
77	n/a	module = loader.load_module('_pkg')
78	n/a	self.assertIn('_pkg', sys.modules)
79	n/a	check = {'__name__': '_pkg', '__file__': mapping['_pkg.__init__'],
80	n/a	'__path__': [os.path.dirname(mapping['_pkg.__init__'])],
81	n/a	'__package__': '_pkg'}
82	n/a	for attr, value in check.items():
83	n/a	self.assertEqual(getattr(module, attr), value)
84	n/a
85	n/a
86	n/a	def test_lacking_parent(self):
87	n/a	with source_util.create_modules('_pkg.__init__', '_pkg.mod')as mapping:
88	n/a	loader = _bootstrap.SourceFileLoader('_pkg.mod',
89	n/a	mapping['_pkg.mod'])
90	n/a	module = loader.load_module('_pkg.mod')
91	n/a	self.assertIn('_pkg.mod', sys.modules)
92	n/a	check = {'__name__': '_pkg.mod', '__file__': mapping['_pkg.mod'],
93	n/a	'__package__': '_pkg'}
94	n/a	for attr, value in check.items():
95	n/a	self.assertEqual(getattr(module, attr), value)
96	n/a
97	n/a	def fake_mtime(self, fxn):
98	n/a	"""Fake mtime to always be higher than expected."""
99	n/a	return lambda name: fxn(name) + 1
100	n/a
101	n/a	def test_module_reuse(self):
102	n/a	with source_util.create_modules('_temp') as mapping:
103	n/a	loader = _bootstrap.SourceFileLoader('_temp', mapping['_temp'])
104	n/a	module = loader.load_module('_temp')
105	n/a	module_id = id(module)
106	n/a	module_dict_id = id(module.__dict__)
107	n/a	with open(mapping['_temp'], 'w') as file:
108	n/a	file.write("testing_var = 42\n")
109	n/a	module = loader.load_module('_temp')
110	n/a	self.assertIn('testing_var', module.__dict__,
111	n/a	"'testing_var' not in "
112	n/a	"{0}".format(list(module.__dict__.keys())))
113	n/a	self.assertEqual(module, sys.modules['_temp'])
114	n/a	self.assertEqual(id(module), module_id)
115	n/a	self.assertEqual(id(module.__dict__), module_dict_id)
116	n/a
117	n/a	def test_state_after_failure(self):
118	n/a	# A failed reload should leave the original module intact.
119	n/a	attributes = ('__file__', '__path__', '__package__')
120	n/a	value = '<test>'
121	n/a	name = '_temp'
122	n/a	with source_util.create_modules(name) as mapping:
123	n/a	orig_module = imp.new_module(name)
124	n/a	for attr in attributes:
125	n/a	setattr(orig_module, attr, value)
126	n/a	with open(mapping[name], 'w') as file:
127	n/a	file.write('+++ bad syntax +++')
128	n/a	loader = _bootstrap.SourceFileLoader('_temp', mapping['_temp'])
129	n/a	with self.assertRaises(SyntaxError):
130	n/a	loader.load_module(name)
131	n/a	for attr in attributes:
132	n/a	self.assertEqual(getattr(orig_module, attr), value)
133	n/a
134	n/a	# [syntax error]
135	n/a	def test_bad_syntax(self):
136	n/a	with source_util.create_modules('_temp') as mapping:
137	n/a	with open(mapping['_temp'], 'w') as file:
138	n/a	file.write('=')
139	n/a	loader = _bootstrap.SourceFileLoader('_temp', mapping['_temp'])
140	n/a	with self.assertRaises(SyntaxError):
141	n/a	loader.load_module('_temp')
142	n/a	self.assertNotIn('_temp', sys.modules)
143	n/a
144	n/a	def test_file_from_empty_string_dir(self):
145	n/a	# Loading a module found from an empty string entry on sys.path should
146	n/a	# not only work, but keep all attributes relative.
147	n/a	file_path = '_temp.py'
148	n/a	with open(file_path, 'w') as file:
149	n/a	file.write("# test file for importlib")
150	n/a	try:
151	n/a	with util.uncache('_temp'):
152	n/a	loader = _bootstrap.SourceFileLoader('_temp', file_path)
153	n/a	mod = loader.load_module('_temp')
154	n/a	self.assertEqual(file_path, mod.__file__)
155	n/a	self.assertEqual(imp.cache_from_source(file_path),
156	n/a	mod.__cached__)
157	n/a	finally:
158	n/a	os.unlink(file_path)
159	n/a	pycache = os.path.dirname(imp.cache_from_source(file_path))
160	n/a	shutil.rmtree(pycache)
161	n/a
162	n/a	def test_timestamp_overflow(self):
163	n/a	# When a modification timestamp is larger than 2**32, it should be
164	n/a	# truncated rather than raise an OverflowError.
165	n/a	with source_util.create_modules('_temp') as mapping:
166	n/a	source = mapping['_temp']
167	n/a	compiled = imp.cache_from_source(source)
168	n/a	with open(source, 'w') as f:
169	n/a	f.write("x = 5")
170	n/a	try:
171	n/a	os.utime(source, (2 33 - 5, 2 33 - 5))
172	n/a	except OverflowError:
173	n/a	self.skipTest("cannot set modification time to large integer")
174	n/a	except OSError as e:
175	n/a	if e.errno != getattr(errno, 'EOVERFLOW', None):
176	n/a	raise
177	n/a	self.skipTest("cannot set modification time to large integer ({})".format(e))
178	n/a	loader = _bootstrap.SourceFileLoader('_temp', mapping['_temp'])
179	n/a	mod = loader.load_module('_temp')
180	n/a	# Sanity checks.
181	n/a	self.assertEqual(mod.__cached__, compiled)
182	n/a	self.assertEqual(mod.x, 5)
183	n/a	# The pyc file was created.
184	n/a	os.stat(compiled)
185	n/a
186	n/a
187	n/a	class BadBytecodeTest(unittest.TestCase):
188	n/a
189	n/a	def import_(self, file, module_name):
190	n/a	loader = self.loader(module_name, file)
191	n/a	module = loader.load_module(module_name)
192	n/a	self.assertIn(module_name, sys.modules)
193	n/a
194	n/a	def manipulate_bytecode(self, name, mapping, manipulator, *,
195	n/a	del_source=False):
196	n/a	"""Manipulate the bytecode of a module by passing it into a callable
197	n/a	that returns what to use as the new bytecode."""
198	n/a	try:
199	n/a	del sys.modules['_temp']
200	n/a	except KeyError:
201	n/a	pass
202	n/a	py_compile.compile(mapping[name])
203	n/a	if not del_source:
204	n/a	bytecode_path = imp.cache_from_source(mapping[name])
205	n/a	else:
206	n/a	os.unlink(mapping[name])
207	n/a	bytecode_path = make_legacy_pyc(mapping[name])
208	n/a	if manipulator:
209	n/a	with open(bytecode_path, 'rb') as file:
210	n/a	bc = file.read()
211	n/a	new_bc = manipulator(bc)
212	n/a	with open(bytecode_path, 'wb') as file:
213	n/a	if new_bc is not None:
214	n/a	file.write(new_bc)
215	n/a	return bytecode_path
216	n/a
217	n/a	def _test_empty_file(self, test, *, del_source=False):
218	n/a	with source_util.create_modules('_temp') as mapping:
219	n/a	bc_path = self.manipulate_bytecode('_temp', mapping,
220	n/a	lambda bc: b'',
221	n/a	del_source=del_source)
222	n/a	test('_temp', mapping, bc_path)
223	n/a
224	n/a	@source_util.writes_bytecode_files
225	n/a	def _test_partial_magic(self, test, *, del_source=False):
226	n/a	# When their are less than 4 bytes to a .pyc, regenerate it if
227	n/a	# possible, else raise ImportError.
228	n/a	with source_util.create_modules('_temp') as mapping:
229	n/a	bc_path = self.manipulate_bytecode('_temp', mapping,
230	n/a	lambda bc: bc[:3],
231	n/a	del_source=del_source)
232	n/a	test('_temp', mapping, bc_path)
233	n/a
234	n/a	def _test_magic_only(self, test, *, del_source=False):
235	n/a	with source_util.create_modules('_temp') as mapping:
236	n/a	bc_path = self.manipulate_bytecode('_temp', mapping,
237	n/a	lambda bc: bc[:4],
238	n/a	del_source=del_source)
239	n/a	test('_temp', mapping, bc_path)
240	n/a
241	n/a	def _test_partial_timestamp(self, test, *, del_source=False):
242	n/a	with source_util.create_modules('_temp') as mapping:
243	n/a	bc_path = self.manipulate_bytecode('_temp', mapping,
244	n/a	lambda bc: bc[:7],
245	n/a	del_source=del_source)
246	n/a	test('_temp', mapping, bc_path)
247	n/a
248	n/a	def _test_partial_size(self, test, *, del_source=False):
249	n/a	with source_util.create_modules('_temp') as mapping:
250	n/a	bc_path = self.manipulate_bytecode('_temp', mapping,
251	n/a	lambda bc: bc[:11],
252	n/a	del_source=del_source)
253	n/a	test('_temp', mapping, bc_path)
254	n/a
255	n/a	def _test_no_marshal(self, *, del_source=False):
256	n/a	with source_util.create_modules('_temp') as mapping:
257	n/a	bc_path = self.manipulate_bytecode('_temp', mapping,
258	n/a	lambda bc: bc[:12],
259	n/a	del_source=del_source)
260	n/a	file_path = mapping['_temp'] if not del_source else bc_path
261	n/a	with self.assertRaises(EOFError):
262	n/a	self.import_(file_path, '_temp')
263	n/a
264	n/a	def _test_non_code_marshal(self, *, del_source=False):
265	n/a	with source_util.create_modules('_temp') as mapping:
266	n/a	bytecode_path = self.manipulate_bytecode('_temp', mapping,
267	n/a	lambda bc: bc[:12] + marshal.dumps(b'abcd'),
268	n/a	del_source=del_source)
269	n/a	file_path = mapping['_temp'] if not del_source else bytecode_path
270	n/a	with self.assertRaises(ImportError) as cm:
271	n/a	self.import_(file_path, '_temp')
272	n/a	self.assertEqual(cm.exception.name, '_temp')
273	n/a	self.assertEqual(cm.exception.path, bytecode_path)
274	n/a
275	n/a	def _test_bad_marshal(self, *, del_source=False):
276	n/a	with source_util.create_modules('_temp') as mapping:
277	n/a	bytecode_path = self.manipulate_bytecode('_temp', mapping,
278	n/a	lambda bc: bc[:12] + b'<test>',
279	n/a	del_source=del_source)
280	n/a	file_path = mapping['_temp'] if not del_source else bytecode_path
281	n/a	with self.assertRaises(EOFError):
282	n/a	self.import_(file_path, '_temp')
283	n/a
284	n/a	def _test_bad_magic(self, test, *, del_source=False):
285	n/a	with source_util.create_modules('_temp') as mapping:
286	n/a	bc_path = self.manipulate_bytecode('_temp', mapping,
287	n/a	lambda bc: b'\x00\x00\x00\x00' + bc[4:])
288	n/a	test('_temp', mapping, bc_path)
289	n/a
290	n/a
291	n/a	class SourceLoaderBadBytecodeTest(BadBytecodeTest):
292	n/a
293	n/a	loader = _bootstrap.SourceFileLoader
294	n/a
295	n/a	@source_util.writes_bytecode_files
296	n/a	def test_empty_file(self):
297	n/a	# When a .pyc is empty, regenerate it if possible, else raise
298	n/a	# ImportError.
299	n/a	def test(name, mapping, bytecode_path):
300	n/a	self.import_(mapping[name], name)
301	n/a	with open(bytecode_path, 'rb') as file:
302	n/a	self.assertGreater(len(file.read()), 12)
303	n/a
304	n/a	self._test_empty_file(test)
305	n/a
306	n/a	def test_partial_magic(self):
307	n/a	def test(name, mapping, bytecode_path):
308	n/a	self.import_(mapping[name], name)
309	n/a	with open(bytecode_path, 'rb') as file:
310	n/a	self.assertGreater(len(file.read()), 12)
311	n/a
312	n/a	self._test_partial_magic(test)
313	n/a
314	n/a	@source_util.writes_bytecode_files
315	n/a	def test_magic_only(self):
316	n/a	# When there is only the magic number, regenerate the .pyc if possible,
317	n/a	# else raise EOFError.
318	n/a	def test(name, mapping, bytecode_path):
319	n/a	self.import_(mapping[name], name)
320	n/a	with open(bytecode_path, 'rb') as file:
321	n/a	self.assertGreater(len(file.read()), 12)
322	n/a
323	n/a	self._test_magic_only(test)
324	n/a
325	n/a	@source_util.writes_bytecode_files
326	n/a	def test_bad_magic(self):
327	n/a	# When the magic number is different, the bytecode should be
328	n/a	# regenerated.
329	n/a	def test(name, mapping, bytecode_path):
330	n/a	self.import_(mapping[name], name)
331	n/a	with open(bytecode_path, 'rb') as bytecode_file:
332	n/a	self.assertEqual(bytecode_file.read(4), imp.get_magic())
333	n/a
334	n/a	self._test_bad_magic(test)
335	n/a
336	n/a	@source_util.writes_bytecode_files
337	n/a	def test_partial_timestamp(self):
338	n/a	# When the timestamp is partial, regenerate the .pyc, else
339	n/a	# raise EOFError.
340	n/a	def test(name, mapping, bc_path):
341	n/a	self.import_(mapping[name], name)
342	n/a	with open(bc_path, 'rb') as file:
343	n/a	self.assertGreater(len(file.read()), 12)
344	n/a
345	n/a	self._test_partial_timestamp(test)
346	n/a
347	n/a	@source_util.writes_bytecode_files
348	n/a	def test_partial_size(self):
349	n/a	# When the size is partial, regenerate the .pyc, else
350	n/a	# raise EOFError.
351	n/a	def test(name, mapping, bc_path):
352	n/a	self.import_(mapping[name], name)
353	n/a	with open(bc_path, 'rb') as file:
354	n/a	self.assertGreater(len(file.read()), 12)
355	n/a
356	n/a	self._test_partial_size(test)
357	n/a
358	n/a	@source_util.writes_bytecode_files
359	n/a	def test_no_marshal(self):
360	n/a	# When there is only the magic number and timestamp, raise EOFError.
361	n/a	self._test_no_marshal()
362	n/a
363	n/a	@source_util.writes_bytecode_files
364	n/a	def test_non_code_marshal(self):
365	n/a	self._test_non_code_marshal()
366	n/a	# XXX ImportError when sourceless
367	n/a
368	n/a	# [bad marshal]
369	n/a	@source_util.writes_bytecode_files
370	n/a	def test_bad_marshal(self):
371	n/a	# Bad marshal data should raise a ValueError.
372	n/a	self._test_bad_marshal()
373	n/a
374	n/a	# [bad timestamp]
375	n/a	@source_util.writes_bytecode_files
376	n/a	def test_old_timestamp(self):
377	n/a	# When the timestamp is older than the source, bytecode should be
378	n/a	# regenerated.
379	n/a	zeros = b'\x00\x00\x00\x00'
380	n/a	with source_util.create_modules('_temp') as mapping:
381	n/a	py_compile.compile(mapping['_temp'])
382	n/a	bytecode_path = imp.cache_from_source(mapping['_temp'])
383	n/a	with open(bytecode_path, 'r+b') as bytecode_file:
384	n/a	bytecode_file.seek(4)
385	n/a	bytecode_file.write(zeros)
386	n/a	self.import_(mapping['_temp'], '_temp')
387	n/a	source_mtime = os.path.getmtime(mapping['_temp'])
388	n/a	source_timestamp = importlib._w_long(source_mtime)
389	n/a	with open(bytecode_path, 'rb') as bytecode_file:
390	n/a	bytecode_file.seek(4)
391	n/a	self.assertEqual(bytecode_file.read(4), source_timestamp)
392	n/a
393	n/a	# [bytecode read-only]
394	n/a	@source_util.writes_bytecode_files
395	n/a	def test_read_only_bytecode(self):
396	n/a	# When bytecode is read-only but should be rewritten, fail silently.
397	n/a	with source_util.create_modules('_temp') as mapping:
398	n/a	# Create bytecode that will need to be re-created.
399	n/a	py_compile.compile(mapping['_temp'])
400	n/a	bytecode_path = imp.cache_from_source(mapping['_temp'])
401	n/a	with open(bytecode_path, 'r+b') as bytecode_file:
402	n/a	bytecode_file.seek(0)
403	n/a	bytecode_file.write(b'\x00\x00\x00\x00')
404	n/a	# Make the bytecode read-only.
405	n/a	os.chmod(bytecode_path,
406	n/a	stat.S_IRUSR \| stat.S_IRGRP \| stat.S_IROTH)
407	n/a	try:
408	n/a	# Should not raise IOError!
409	n/a	self.import_(mapping['_temp'], '_temp')
410	n/a	finally:
411	n/a	# Make writable for eventual clean-up.
412	n/a	os.chmod(bytecode_path, stat.S_IWUSR)
413	n/a
414	n/a
415	n/a	class SourcelessLoaderBadBytecodeTest(BadBytecodeTest):
416	n/a
417	n/a	loader = _bootstrap.SourcelessFileLoader
418	n/a
419	n/a	def test_empty_file(self):
420	n/a	def test(name, mapping, bytecode_path):
421	n/a	with self.assertRaises(ImportError) as cm:
422	n/a	self.import_(bytecode_path, name)
423	n/a	self.assertEqual(cm.exception.name, name)
424	n/a	self.assertEqual(cm.exception.path, bytecode_path)
425	n/a
426	n/a	self._test_empty_file(test, del_source=True)
427	n/a
428	n/a	def test_partial_magic(self):
429	n/a	def test(name, mapping, bytecode_path):
430	n/a	with self.assertRaises(ImportError) as cm:
431	n/a	self.import_(bytecode_path, name)
432	n/a	self.assertEqual(cm.exception.name, name)
433	n/a	self.assertEqual(cm.exception.path, bytecode_path)
434	n/a	self._test_partial_magic(test, del_source=True)
435	n/a
436	n/a	def test_magic_only(self):
437	n/a	def test(name, mapping, bytecode_path):
438	n/a	with self.assertRaises(EOFError):
439	n/a	self.import_(bytecode_path, name)
440	n/a
441	n/a	self._test_magic_only(test, del_source=True)
442	n/a
443	n/a	def test_bad_magic(self):
444	n/a	def test(name, mapping, bytecode_path):
445	n/a	with self.assertRaises(ImportError) as cm:
446	n/a	self.import_(bytecode_path, name)
447	n/a	self.assertEqual(cm.exception.name, name)
448	n/a	self.assertEqual(cm.exception.path, bytecode_path)
449	n/a
450	n/a	self._test_bad_magic(test, del_source=True)
451	n/a
452	n/a	def test_partial_timestamp(self):
453	n/a	def test(name, mapping, bytecode_path):
454	n/a	with self.assertRaises(EOFError):
455	n/a	self.import_(bytecode_path, name)
456	n/a
457	n/a	self._test_partial_timestamp(test, del_source=True)
458	n/a
459	n/a	def test_partial_size(self):
460	n/a	def test(name, mapping, bytecode_path):
461	n/a	with self.assertRaises(EOFError):
462	n/a	self.import_(bytecode_path, name)
463	n/a
464	n/a	self._test_partial_size(test, del_source=True)
465	n/a
466	n/a	def test_no_marshal(self):
467	n/a	self._test_no_marshal(del_source=True)
468	n/a
469	n/a	def test_non_code_marshal(self):
470	n/a	self._test_non_code_marshal(del_source=True)
471	n/a
472	n/a
473	n/a	def test_main():
474	n/a	from test.support import run_unittest
475	n/a	run_unittest(SimpleTest,
476	n/a	SourceLoaderBadBytecodeTest,
477	n/a	SourcelessLoaderBadBytecodeTest
478	n/a	)
479	n/a
480	n/a
481	n/a	if __name__ == '__main__':
482	n/a	test_main()