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

#	count	content
1	n/a	import importlib
2	n/a	from importlib import abc
3	n/a
4	n/a	from .. import abc as testing_abc
5	n/a	from .. import util
6	n/a	from . import util as source_util
7	n/a
8	n/a	import imp
9	n/a	import inspect
10	n/a	import io
11	n/a	import marshal
12	n/a	import os
13	n/a	import sys
14	n/a	import types
15	n/a	import unittest
16	n/a	import warnings
17	n/a
18	n/a
19	n/a	class SourceOnlyLoaderMock(abc.SourceLoader):
20	n/a
21	n/a	# Globals that should be defined for all modules.
22	n/a	source = (b"_ = '::'.join([__name__, __file__, __cached__, __package__, "
23	n/a	b"repr(__loader__)])")
24	n/a
25	n/a	def __init__(self, path):
26	n/a	self.path = path
27	n/a
28	n/a	def get_data(self, path):
29	n/a	assert self.path == path
30	n/a	return self.source
31	n/a
32	n/a	def get_filename(self, fullname):
33	n/a	return self.path
34	n/a
35	n/a
36	n/a	class SourceLoaderMock(SourceOnlyLoaderMock):
37	n/a
38	n/a	source_mtime = 1
39	n/a
40	n/a	def __init__(self, path, magic=imp.get_magic()):
41	n/a	super().__init__(path)
42	n/a	self.bytecode_path = imp.cache_from_source(self.path)
43	n/a	self.source_size = len(self.source)
44	n/a	data = bytearray(magic)
45	n/a	data.extend(importlib._w_long(self.source_mtime))
46	n/a	data.extend(importlib._w_long(self.source_size))
47	n/a	code_object = compile(self.source, self.path, 'exec',
48	n/a	dont_inherit=True)
49	n/a	data.extend(marshal.dumps(code_object))
50	n/a	self.bytecode = bytes(data)
51	n/a	self.written = {}
52	n/a
53	n/a	def get_data(self, path):
54	n/a	if path == self.path:
55	n/a	return super().get_data(path)
56	n/a	elif path == self.bytecode_path:
57	n/a	return self.bytecode
58	n/a	else:
59	n/a	raise IOError
60	n/a
61	n/a	def path_stats(self, path):
62	n/a	assert path == self.path
63	n/a	return {'mtime': self.source_mtime, 'size': self.source_size}
64	n/a
65	n/a	def set_data(self, path, data):
66	n/a	self.written[path] = bytes(data)
67	n/a	return path == self.bytecode_path
68	n/a
69	n/a
70	n/a	class PyLoaderMock(abc.PyLoader):
71	n/a
72	n/a	# Globals that should be defined for all modules.
73	n/a	source = (b"_ = '::'.join([__name__, __file__, __package__, "
74	n/a	b"repr(__loader__)])")
75	n/a
76	n/a	def __init__(self, data):
77	n/a	"""Take a dict of 'module_name: path' pairings.
78	n/a
79	n/a	Paths should have no file extension, allowing packages to be denoted by
80	n/a	ending in '__init__'.
81	n/a
82	n/a	"""
83	n/a	self.module_paths = data
84	n/a	self.path_to_module = {val:key for key,val in data.items()}
85	n/a
86	n/a	def get_data(self, path):
87	n/a	if path not in self.path_to_module:
88	n/a	raise IOError
89	n/a	return self.source
90	n/a
91	n/a	def is_package(self, name):
92	n/a	filename = os.path.basename(self.get_filename(name))
93	n/a	return os.path.splitext(filename)[0] == '__init__'
94	n/a
95	n/a	def source_path(self, name):
96	n/a	try:
97	n/a	return self.module_paths[name]
98	n/a	except KeyError:
99	n/a	raise ImportError
100	n/a
101	n/a	def get_filename(self, name):
102	n/a	"""Silence deprecation warning."""
103	n/a	with warnings.catch_warnings(record=True) as w:
104	n/a	warnings.simplefilter("always")
105	n/a	path = super().get_filename(name)
106	n/a	assert len(w) == 1
107	n/a	assert issubclass(w[0].category, DeprecationWarning)
108	n/a	return path
109	n/a
110	n/a
111	n/a	class PyLoaderCompatMock(PyLoaderMock):
112	n/a
113	n/a	"""Mock that matches what is suggested to have a loader that is compatible
114	n/a	from Python 3.1 onwards."""
115	n/a
116	n/a	def get_filename(self, fullname):
117	n/a	try:
118	n/a	return self.module_paths[fullname]
119	n/a	except KeyError:
120	n/a	raise ImportError
121	n/a
122	n/a	def source_path(self, fullname):
123	n/a	try:
124	n/a	return self.get_filename(fullname)
125	n/a	except ImportError:
126	n/a	return None
127	n/a
128	n/a
129	n/a	class PyPycLoaderMock(abc.PyPycLoader, PyLoaderMock):
130	n/a
131	n/a	default_mtime = 1
132	n/a
133	n/a	def __init__(self, source, bc={}):
134	n/a	"""Initialize mock.
135	n/a
136	n/a	'bc' is a dict keyed on a module's name. The value is dict with
137	n/a	possible keys of 'path', 'mtime', 'magic', and 'bc'. Except for 'path',
138	n/a	each of those keys control if any part of created bytecode is to
139	n/a	deviate from default values.
140	n/a
141	n/a	"""
142	n/a	super().__init__(source)
143	n/a	self.module_bytecode = {}
144	n/a	self.path_to_bytecode = {}
145	n/a	self.bytecode_to_path = {}
146	n/a	for name, data in bc.items():
147	n/a	self.path_to_bytecode[data['path']] = name
148	n/a	self.bytecode_to_path[name] = data['path']
149	n/a	magic = data.get('magic', imp.get_magic())
150	n/a	mtime = importlib._w_long(data.get('mtime', self.default_mtime))
151	n/a	source_size = importlib._w_long(len(self.source) & 0xFFFFFFFF)
152	n/a	if 'bc' in data:
153	n/a	bc = data['bc']
154	n/a	else:
155	n/a	bc = self.compile_bc(name)
156	n/a	self.module_bytecode[name] = magic + mtime + source_size + bc
157	n/a
158	n/a	def compile_bc(self, name):
159	n/a	source_path = self.module_paths.get(name, '<test>') or '<test>'
160	n/a	code = compile(self.source, source_path, 'exec')
161	n/a	return marshal.dumps(code)
162	n/a
163	n/a	def source_mtime(self, name):
164	n/a	if name in self.module_paths:
165	n/a	return self.default_mtime
166	n/a	elif name in self.module_bytecode:
167	n/a	return None
168	n/a	else:
169	n/a	raise ImportError
170	n/a
171	n/a	def bytecode_path(self, name):
172	n/a	try:
173	n/a	return self.bytecode_to_path[name]
174	n/a	except KeyError:
175	n/a	if name in self.module_paths:
176	n/a	return None
177	n/a	else:
178	n/a	raise ImportError
179	n/a
180	n/a	def write_bytecode(self, name, bytecode):
181	n/a	self.module_bytecode[name] = bytecode
182	n/a	return True
183	n/a
184	n/a	def get_data(self, path):
185	n/a	if path in self.path_to_module:
186	n/a	return super().get_data(path)
187	n/a	elif path in self.path_to_bytecode:
188	n/a	name = self.path_to_bytecode[path]
189	n/a	return self.module_bytecode[name]
190	n/a	else:
191	n/a	raise IOError
192	n/a
193	n/a	def is_package(self, name):
194	n/a	try:
195	n/a	return super().is_package(name)
196	n/a	except TypeError:
197	n/a	return '__init__' in self.bytecode_to_path[name]
198	n/a
199	n/a	def get_code(self, name):
200	n/a	with warnings.catch_warnings(record=True) as w:
201	n/a	warnings.simplefilter("always")
202	n/a	code_object = super().get_code(name)
203	n/a	assert len(w) == 1
204	n/a	assert issubclass(w[0].category, DeprecationWarning)
205	n/a	return code_object
206	n/a
207	n/a	class PyLoaderTests(testing_abc.LoaderTests):
208	n/a
209	n/a	"""Tests for importlib.abc.PyLoader."""
210	n/a
211	n/a	mocker = PyLoaderMock
212	n/a
213	n/a	def eq_attrs(self, ob, **kwargs):
214	n/a	for attr, val in kwargs.items():
215	n/a	found = getattr(ob, attr)
216	n/a	self.assertEqual(found, val,
217	n/a	"{} attribute: {} != {}".format(attr, found, val))
218	n/a
219	n/a	def test_module(self):
220	n/a	name = '<module>'
221	n/a	path = os.path.join('', 'path', 'to', 'module')
222	n/a	mock = self.mocker({name: path})
223	n/a	with util.uncache(name):
224	n/a	module = mock.load_module(name)
225	n/a	self.assertIn(name, sys.modules)
226	n/a	self.eq_attrs(module, __name__=name, __file__=path, __package__='',
227	n/a	__loader__=mock)
228	n/a	self.assertTrue(not hasattr(module, '__path__'))
229	n/a	return mock, name
230	n/a
231	n/a	def test_package(self):
232	n/a	name = '<pkg>'
233	n/a	path = os.path.join('path', 'to', name, '__init__')
234	n/a	mock = self.mocker({name: path})
235	n/a	with util.uncache(name):
236	n/a	module = mock.load_module(name)
237	n/a	self.assertIn(name, sys.modules)
238	n/a	self.eq_attrs(module, __name__=name, __file__=path,
239	n/a	__path__=[os.path.dirname(path)], __package__=name,
240	n/a	__loader__=mock)
241	n/a	return mock, name
242	n/a
243	n/a	def test_lacking_parent(self):
244	n/a	name = 'pkg.mod'
245	n/a	path = os.path.join('path', 'to', 'pkg', 'mod')
246	n/a	mock = self.mocker({name: path})
247	n/a	with util.uncache(name):
248	n/a	module = mock.load_module(name)
249	n/a	self.assertIn(name, sys.modules)
250	n/a	self.eq_attrs(module, __name__=name, __file__=path, __package__='pkg',
251	n/a	__loader__=mock)
252	n/a	self.assertFalse(hasattr(module, '__path__'))
253	n/a	return mock, name
254	n/a
255	n/a	def test_module_reuse(self):
256	n/a	name = 'mod'
257	n/a	path = os.path.join('path', 'to', 'mod')
258	n/a	module = imp.new_module(name)
259	n/a	mock = self.mocker({name: path})
260	n/a	with util.uncache(name):
261	n/a	sys.modules[name] = module
262	n/a	loaded_module = mock.load_module(name)
263	n/a	self.assertIs(loaded_module, module)
264	n/a	self.assertIs(sys.modules[name], module)
265	n/a	return mock, name
266	n/a
267	n/a	def test_state_after_failure(self):
268	n/a	name = "mod"
269	n/a	module = imp.new_module(name)
270	n/a	module.blah = None
271	n/a	mock = self.mocker({name: os.path.join('path', 'to', 'mod')})
272	n/a	mock.source = b"1/0"
273	n/a	with util.uncache(name):
274	n/a	sys.modules[name] = module
275	n/a	with self.assertRaises(ZeroDivisionError):
276	n/a	mock.load_module(name)
277	n/a	self.assertIs(sys.modules[name], module)
278	n/a	self.assertTrue(hasattr(module, 'blah'))
279	n/a	return mock
280	n/a
281	n/a	def test_unloadable(self):
282	n/a	name = "mod"
283	n/a	mock = self.mocker({name: os.path.join('path', 'to', 'mod')})
284	n/a	mock.source = b"1/0"
285	n/a	with util.uncache(name):
286	n/a	with self.assertRaises(ZeroDivisionError):
287	n/a	mock.load_module(name)
288	n/a	self.assertNotIn(name, sys.modules)
289	n/a	return mock
290	n/a
291	n/a
292	n/a	class PyLoaderCompatTests(PyLoaderTests):
293	n/a
294	n/a	"""Test that the suggested code to make a loader that is compatible from
295	n/a	Python 3.1 forward works."""
296	n/a
297	n/a	mocker = PyLoaderCompatMock
298	n/a
299	n/a
300	n/a	class PyLoaderInterfaceTests(unittest.TestCase):
301	n/a
302	n/a	"""Tests for importlib.abc.PyLoader to make sure that when source_path()
303	n/a	doesn't return a path everything works as expected."""
304	n/a
305	n/a	def test_no_source_path(self):
306	n/a	# No source path should lead to ImportError.
307	n/a	name = 'mod'
308	n/a	mock = PyLoaderMock({})
309	n/a	with util.uncache(name), self.assertRaises(ImportError):
310	n/a	mock.load_module(name)
311	n/a
312	n/a	def test_source_path_is_None(self):
313	n/a	name = 'mod'
314	n/a	mock = PyLoaderMock({name: None})
315	n/a	with util.uncache(name), self.assertRaises(ImportError):
316	n/a	mock.load_module(name)
317	n/a
318	n/a	def test_get_filename_with_source_path(self):
319	n/a	# get_filename() should return what source_path() returns.
320	n/a	name = 'mod'
321	n/a	path = os.path.join('path', 'to', 'source')
322	n/a	mock = PyLoaderMock({name: path})
323	n/a	with util.uncache(name):
324	n/a	self.assertEqual(mock.get_filename(name), path)
325	n/a
326	n/a	def test_get_filename_no_source_path(self):
327	n/a	# get_filename() should raise ImportError if source_path returns None.
328	n/a	name = 'mod'
329	n/a	mock = PyLoaderMock({name: None})
330	n/a	with util.uncache(name), self.assertRaises(ImportError):
331	n/a	mock.get_filename(name)
332	n/a
333	n/a
334	n/a	class PyPycLoaderTests(PyLoaderTests):
335	n/a
336	n/a	"""Tests for importlib.abc.PyPycLoader."""
337	n/a
338	n/a	mocker = PyPycLoaderMock
339	n/a
340	n/a	@source_util.writes_bytecode_files
341	n/a	def verify_bytecode(self, mock, name):
342	n/a	assert name in mock.module_paths
343	n/a	self.assertIn(name, mock.module_bytecode)
344	n/a	magic = mock.module_bytecode[name][:4]
345	n/a	self.assertEqual(magic, imp.get_magic())
346	n/a	mtime = importlib._r_long(mock.module_bytecode[name][4:8])
347	n/a	self.assertEqual(mtime, 1)
348	n/a	source_size = mock.module_bytecode[name][8:12]
349	n/a	self.assertEqual(len(mock.source) & 0xFFFFFFFF,
350	n/a	importlib._r_long(source_size))
351	n/a	bc = mock.module_bytecode[name][12:]
352	n/a	self.assertEqual(bc, mock.compile_bc(name))
353	n/a
354	n/a	def test_module(self):
355	n/a	mock, name = super().test_module()
356	n/a	self.verify_bytecode(mock, name)
357	n/a
358	n/a	def test_package(self):
359	n/a	mock, name = super().test_package()
360	n/a	self.verify_bytecode(mock, name)
361	n/a
362	n/a	def test_lacking_parent(self):
363	n/a	mock, name = super().test_lacking_parent()
364	n/a	self.verify_bytecode(mock, name)
365	n/a
366	n/a	def test_module_reuse(self):
367	n/a	mock, name = super().test_module_reuse()
368	n/a	self.verify_bytecode(mock, name)
369	n/a
370	n/a	def test_state_after_failure(self):
371	n/a	super().test_state_after_failure()
372	n/a
373	n/a	def test_unloadable(self):
374	n/a	super().test_unloadable()
375	n/a
376	n/a
377	n/a	class PyPycLoaderInterfaceTests(unittest.TestCase):
378	n/a
379	n/a	"""Test for the interface of importlib.abc.PyPycLoader."""
380	n/a
381	n/a	def get_filename_check(self, src_path, bc_path, expect):
382	n/a	name = 'mod'
383	n/a	mock = PyPycLoaderMock({name: src_path}, {name: {'path': bc_path}})
384	n/a	with util.uncache(name):
385	n/a	assert mock.source_path(name) == src_path
386	n/a	assert mock.bytecode_path(name) == bc_path
387	n/a	self.assertEqual(mock.get_filename(name), expect)
388	n/a
389	n/a	def test_filename_with_source_bc(self):
390	n/a	# When source and bytecode paths present, return the source path.
391	n/a	self.get_filename_check('source_path', 'bc_path', 'source_path')
392	n/a
393	n/a	def test_filename_with_source_no_bc(self):
394	n/a	# With source but no bc, return source path.
395	n/a	self.get_filename_check('source_path', None, 'source_path')
396	n/a
397	n/a	def test_filename_with_no_source_bc(self):
398	n/a	# With not source but bc, return the bc path.
399	n/a	self.get_filename_check(None, 'bc_path', 'bc_path')
400	n/a
401	n/a	def test_filename_with_no_source_or_bc(self):
402	n/a	# With no source or bc, raise ImportError.
403	n/a	name = 'mod'
404	n/a	mock = PyPycLoaderMock({name: None}, {name: {'path': None}})
405	n/a	with util.uncache(name), self.assertRaises(ImportError):
406	n/a	mock.get_filename(name)
407	n/a
408	n/a
409	n/a	class SkipWritingBytecodeTests(unittest.TestCase):
410	n/a
411	n/a	"""Test that bytecode is properly handled based on
412	n/a	sys.dont_write_bytecode."""
413	n/a
414	n/a	@source_util.writes_bytecode_files
415	n/a	def run_test(self, dont_write_bytecode):
416	n/a	name = 'mod'
417	n/a	mock = PyPycLoaderMock({name: os.path.join('path', 'to', 'mod')})
418	n/a	sys.dont_write_bytecode = dont_write_bytecode
419	n/a	with util.uncache(name):
420	n/a	mock.load_module(name)
421	n/a	self.assertIsNot(name in mock.module_bytecode, dont_write_bytecode)
422	n/a
423	n/a	def test_no_bytecode_written(self):
424	n/a	self.run_test(True)
425	n/a
426	n/a	def test_bytecode_written(self):
427	n/a	self.run_test(False)
428	n/a
429	n/a
430	n/a	class RegeneratedBytecodeTests(unittest.TestCase):
431	n/a
432	n/a	"""Test that bytecode is regenerated as expected."""
433	n/a
434	n/a	@source_util.writes_bytecode_files
435	n/a	def test_different_magic(self):
436	n/a	# A different magic number should lead to new bytecode.
437	n/a	name = 'mod'
438	n/a	bad_magic = b'\x00\x00\x00\x00'
439	n/a	assert bad_magic != imp.get_magic()
440	n/a	mock = PyPycLoaderMock({name: os.path.join('path', 'to', 'mod')},
441	n/a	{name: {'path': os.path.join('path', 'to',
442	n/a	'mod.bytecode'),
443	n/a	'magic': bad_magic}})
444	n/a	with util.uncache(name):
445	n/a	mock.load_module(name)
446	n/a	self.assertIn(name, mock.module_bytecode)
447	n/a	magic = mock.module_bytecode[name][:4]
448	n/a	self.assertEqual(magic, imp.get_magic())
449	n/a
450	n/a	@source_util.writes_bytecode_files
451	n/a	def test_old_mtime(self):
452	n/a	# Bytecode with an older mtime should be regenerated.
453	n/a	name = 'mod'
454	n/a	old_mtime = PyPycLoaderMock.default_mtime - 1
455	n/a	mock = PyPycLoaderMock({name: os.path.join('path', 'to', 'mod')},
456	n/a	{name: {'path': 'path/to/mod.bytecode', 'mtime': old_mtime}})
457	n/a	with util.uncache(name):
458	n/a	mock.load_module(name)
459	n/a	self.assertIn(name, mock.module_bytecode)
460	n/a	mtime = importlib._r_long(mock.module_bytecode[name][4:8])
461	n/a	self.assertEqual(mtime, PyPycLoaderMock.default_mtime)
462	n/a
463	n/a
464	n/a	class BadBytecodeFailureTests(unittest.TestCase):
465	n/a
466	n/a	"""Test import failures when there is no source and parts of the bytecode
467	n/a	is bad."""
468	n/a
469	n/a	def test_bad_magic(self):
470	n/a	# A bad magic number should lead to an ImportError.
471	n/a	name = 'mod'
472	n/a	bad_magic = b'\x00\x00\x00\x00'
473	n/a	bc = {name:
474	n/a	{'path': os.path.join('path', 'to', 'mod'),
475	n/a	'magic': bad_magic}}
476	n/a	mock = PyPycLoaderMock({name: None}, bc)
477	n/a	with util.uncache(name), self.assertRaises(ImportError) as cm:
478	n/a	mock.load_module(name)
479	n/a	self.assertEqual(cm.exception.name, name)
480	n/a
481	n/a	def test_no_bytecode(self):
482	n/a	# Missing code object bytecode should lead to an EOFError.
483	n/a	name = 'mod'
484	n/a	bc = {name: {'path': os.path.join('path', 'to', 'mod'), 'bc': b''}}
485	n/a	mock = PyPycLoaderMock({name: None}, bc)
486	n/a	with util.uncache(name), self.assertRaises(EOFError):
487	n/a	mock.load_module(name)
488	n/a
489	n/a	def test_bad_bytecode(self):
490	n/a	# Malformed code object bytecode should lead to a ValueError.
491	n/a	name = 'mod'
492	n/a	bc = {name: {'path': os.path.join('path', 'to', 'mod'), 'bc': b'1234'}}
493	n/a	mock = PyPycLoaderMock({name: None}, bc)
494	n/a	with util.uncache(name), self.assertRaises(ValueError):
495	n/a	mock.load_module(name)
496	n/a
497	n/a
498	n/a	def raise_ImportError(args, *kwargs):
499	n/a	raise ImportError
500	n/a
501	n/a	class MissingPathsTests(unittest.TestCase):
502	n/a
503	n/a	"""Test what happens when a source or bytecode path does not exist (either
504	n/a	from *_path returning None or raising ImportError)."""
505	n/a
506	n/a	def test_source_path_None(self):
507	n/a	# Bytecode should be used when source_path returns None, along with
508	n/a	# __file__ being set to the bytecode path.
509	n/a	name = 'mod'
510	n/a	bytecode_path = 'path/to/mod'
511	n/a	mock = PyPycLoaderMock({name: None}, {name: {'path': bytecode_path}})
512	n/a	with util.uncache(name):
513	n/a	module = mock.load_module(name)
514	n/a	self.assertEqual(module.__file__, bytecode_path)
515	n/a
516	n/a	# Testing for bytecode_path returning None handled by all tests where no
517	n/a	# bytecode initially exists.
518	n/a
519	n/a	def test_all_paths_None(self):
520	n/a	# If all *_path methods return None, raise ImportError.
521	n/a	name = 'mod'
522	n/a	mock = PyPycLoaderMock({name: None})
523	n/a	with util.uncache(name), self.assertRaises(ImportError) as cm:
524	n/a	mock.load_module(name)
525	n/a	self.assertEqual(cm.exception.name, name)
526	n/a
527	n/a	def test_source_path_ImportError(self):
528	n/a	# An ImportError from source_path should trigger an ImportError.
529	n/a	name = 'mod'
530	n/a	mock = PyPycLoaderMock({}, {name: {'path': os.path.join('path', 'to',
531	n/a	'mod')}})
532	n/a	with util.uncache(name), self.assertRaises(ImportError):
533	n/a	mock.load_module(name)
534	n/a
535	n/a	def test_bytecode_path_ImportError(self):
536	n/a	# An ImportError from bytecode_path should trigger an ImportError.
537	n/a	name = 'mod'
538	n/a	mock = PyPycLoaderMock({name: os.path.join('path', 'to', 'mod')})
539	n/a	bad_meth = types.MethodType(raise_ImportError, mock)
540	n/a	mock.bytecode_path = bad_meth
541	n/a	with util.uncache(name), self.assertRaises(ImportError) as cm:
542	n/a	mock.load_module(name)
543	n/a
544	n/a
545	n/a	class SourceLoaderTestHarness(unittest.TestCase):
546	n/a
547	n/a	def setUp(self, , is_package=True, *kwargs):
548	n/a	self.package = 'pkg'
549	n/a	if is_package:
550	n/a	self.path = os.path.join(self.package, '__init__.py')
551	n/a	self.name = self.package
552	n/a	else:
553	n/a	module_name = 'mod'
554	n/a	self.path = os.path.join(self.package, '.'.join(['mod', 'py']))
555	n/a	self.name = '.'.join([self.package, module_name])
556	n/a	self.cached = imp.cache_from_source(self.path)
557	n/a	self.loader = self.loader_mock(self.path, **kwargs)
558	n/a
559	n/a	def verify_module(self, module):
560	n/a	self.assertEqual(module.__name__, self.name)
561	n/a	self.assertEqual(module.__file__, self.path)
562	n/a	self.assertEqual(module.__cached__, self.cached)
563	n/a	self.assertEqual(module.__package__, self.package)
564	n/a	self.assertEqual(module.__loader__, self.loader)
565	n/a	values = module._.split('::')
566	n/a	self.assertEqual(values[0], self.name)
567	n/a	self.assertEqual(values[1], self.path)
568	n/a	self.assertEqual(values[2], self.cached)
569	n/a	self.assertEqual(values[3], self.package)
570	n/a	self.assertEqual(values[4], repr(self.loader))
571	n/a
572	n/a	def verify_code(self, code_object):
573	n/a	module = imp.new_module(self.name)
574	n/a	module.__file__ = self.path
575	n/a	module.__cached__ = self.cached
576	n/a	module.__package__ = self.package
577	n/a	module.__loader__ = self.loader
578	n/a	module.__path__ = []
579	n/a	exec(code_object, module.__dict__)
580	n/a	self.verify_module(module)
581	n/a
582	n/a
583	n/a	class SourceOnlyLoaderTests(SourceLoaderTestHarness):
584	n/a
585	n/a	"""Test importlib.abc.SourceLoader for source-only loading.
586	n/a
587	n/a	Reload testing is subsumed by the tests for
588	n/a	importlib.util.module_for_loader.
589	n/a
590	n/a	"""
591	n/a
592	n/a	loader_mock = SourceOnlyLoaderMock
593	n/a
594	n/a	def test_get_source(self):
595	n/a	# Verify the source code is returned as a string.
596	n/a	# If an IOError is raised by get_data then raise ImportError.
597	n/a	expected_source = self.loader.source.decode('utf-8')
598	n/a	self.assertEqual(self.loader.get_source(self.name), expected_source)
599	n/a	def raise_IOError(path):
600	n/a	raise IOError
601	n/a	self.loader.get_data = raise_IOError
602	n/a	with self.assertRaises(ImportError) as cm:
603	n/a	self.loader.get_source(self.name)
604	n/a	self.assertEqual(cm.exception.name, self.name)
605	n/a
606	n/a	def test_is_package(self):
607	n/a	# Properly detect when loading a package.
608	n/a	self.setUp(is_package=False)
609	n/a	self.assertFalse(self.loader.is_package(self.name))
610	n/a	self.setUp(is_package=True)
611	n/a	self.assertTrue(self.loader.is_package(self.name))
612	n/a	self.assertFalse(self.loader.is_package(self.name + '.__init__'))
613	n/a
614	n/a	def test_get_code(self):
615	n/a	# Verify the code object is created.
616	n/a	code_object = self.loader.get_code(self.name)
617	n/a	self.verify_code(code_object)
618	n/a
619	n/a	def test_load_module(self):
620	n/a	# Loading a module should set __name__, __loader__, __package__,
621	n/a	# __path__ (for packages), __file__, and __cached__.
622	n/a	# The module should also be put into sys.modules.
623	n/a	with util.uncache(self.name):
624	n/a	module = self.loader.load_module(self.name)
625	n/a	self.verify_module(module)
626	n/a	self.assertEqual(module.__path__, [os.path.dirname(self.path)])
627	n/a	self.assertIn(self.name, sys.modules)
628	n/a
629	n/a	def test_package_settings(self):
630	n/a	# __package__ needs to be set, while __path__ is set on if the module
631	n/a	# is a package.
632	n/a	# Testing the values for a package are covered by test_load_module.
633	n/a	self.setUp(is_package=False)
634	n/a	with util.uncache(self.name):
635	n/a	module = self.loader.load_module(self.name)
636	n/a	self.verify_module(module)
637	n/a	self.assertTrue(not hasattr(module, '__path__'))
638	n/a
639	n/a	def test_get_source_encoding(self):
640	n/a	# Source is considered encoded in UTF-8 by default unless otherwise
641	n/a	# specified by an encoding line.
642	n/a	source = "_ = 'Ã¼'"
643	n/a	self.loader.source = source.encode('utf-8')
644	n/a	returned_source = self.loader.get_source(self.name)
645	n/a	self.assertEqual(returned_source, source)
646	n/a	source = "# coding: latin-1\n_ = Ã¼"
647	n/a	self.loader.source = source.encode('latin-1')
648	n/a	returned_source = self.loader.get_source(self.name)
649	n/a	self.assertEqual(returned_source, source)
650	n/a
651	n/a
652	n/a	@unittest.skipIf(sys.dont_write_bytecode, "sys.dont_write_bytecode is true")
653	n/a	class SourceLoaderBytecodeTests(SourceLoaderTestHarness):
654	n/a
655	n/a	"""Test importlib.abc.SourceLoader's use of bytecode.
656	n/a
657	n/a	Source-only testing handled by SourceOnlyLoaderTests.
658	n/a
659	n/a	"""
660	n/a
661	n/a	loader_mock = SourceLoaderMock
662	n/a
663	n/a	def verify_code(self, code_object, *, bytecode_written=False):
664	n/a	super().verify_code(code_object)
665	n/a	if bytecode_written:
666	n/a	self.assertIn(self.cached, self.loader.written)
667	n/a	data = bytearray(imp.get_magic())
668	n/a	data.extend(importlib._w_long(self.loader.source_mtime))
669	n/a	data.extend(importlib._w_long(self.loader.source_size))
670	n/a	data.extend(marshal.dumps(code_object))
671	n/a	self.assertEqual(self.loader.written[self.cached], bytes(data))
672	n/a
673	n/a	def test_code_with_everything(self):
674	n/a	# When everything should work.
675	n/a	code_object = self.loader.get_code(self.name)
676	n/a	self.verify_code(code_object)
677	n/a
678	n/a	def test_no_bytecode(self):
679	n/a	# If no bytecode exists then move on to the source.
680	n/a	self.loader.bytecode_path = "<does not exist>"
681	n/a	# Sanity check
682	n/a	with self.assertRaises(IOError):
683	n/a	bytecode_path = imp.cache_from_source(self.path)
684	n/a	self.loader.get_data(bytecode_path)
685	n/a	code_object = self.loader.get_code(self.name)
686	n/a	self.verify_code(code_object, bytecode_written=True)
687	n/a
688	n/a	def test_code_bad_timestamp(self):
689	n/a	# Bytecode is only used when the timestamp matches the source EXACTLY.
690	n/a	for source_mtime in (0, 2):
691	n/a	assert source_mtime != self.loader.source_mtime
692	n/a	original = self.loader.source_mtime
693	n/a	self.loader.source_mtime = source_mtime
694	n/a	# If bytecode is used then EOFError would be raised by marshal.
695	n/a	self.loader.bytecode = self.loader.bytecode[8:]
696	n/a	code_object = self.loader.get_code(self.name)
697	n/a	self.verify_code(code_object, bytecode_written=True)
698	n/a	self.loader.source_mtime = original
699	n/a
700	n/a	def test_code_bad_magic(self):
701	n/a	# Skip over bytecode with a bad magic number.
702	n/a	self.setUp(magic=b'0000')
703	n/a	# If bytecode is used then EOFError would be raised by marshal.
704	n/a	self.loader.bytecode = self.loader.bytecode[8:]
705	n/a	code_object = self.loader.get_code(self.name)
706	n/a	self.verify_code(code_object, bytecode_written=True)
707	n/a
708	n/a	def test_dont_write_bytecode(self):
709	n/a	# Bytecode is not written if sys.dont_write_bytecode is true.
710	n/a	# Can assume it is false already thanks to the skipIf class decorator.
711	n/a	try:
712	n/a	sys.dont_write_bytecode = True
713	n/a	self.loader.bytecode_path = "<does not exist>"
714	n/a	code_object = self.loader.get_code(self.name)
715	n/a	self.assertNotIn(self.cached, self.loader.written)
716	n/a	finally:
717	n/a	sys.dont_write_bytecode = False
718	n/a
719	n/a	def test_no_set_data(self):
720	n/a	# If set_data is not defined, one can still read bytecode.
721	n/a	self.setUp(magic=b'0000')
722	n/a	original_set_data = self.loader.__class__.set_data
723	n/a	try:
724	n/a	del self.loader.__class__.set_data
725	n/a	code_object = self.loader.get_code(self.name)
726	n/a	self.verify_code(code_object)
727	n/a	finally:
728	n/a	self.loader.__class__.set_data = original_set_data
729	n/a
730	n/a	def test_set_data_raises_exceptions(self):
731	n/a	# Raising NotImplementedError or IOError is okay for set_data.
732	n/a	def raise_exception(exc):
733	n/a	def closure(args, *kwargs):
734	n/a	raise exc
735	n/a	return closure
736	n/a
737	n/a	self.setUp(magic=b'0000')
738	n/a	self.loader.set_data = raise_exception(NotImplementedError)
739	n/a	code_object = self.loader.get_code(self.name)
740	n/a	self.verify_code(code_object)
741	n/a
742	n/a
743	n/a	class SourceLoaderGetSourceTests(unittest.TestCase):
744	n/a
745	n/a	"""Tests for importlib.abc.SourceLoader.get_source()."""
746	n/a
747	n/a	def test_default_encoding(self):
748	n/a	# Should have no problems with UTF-8 text.
749	n/a	name = 'mod'
750	n/a	mock = SourceOnlyLoaderMock('mod.file')
751	n/a	source = 'x = "Ã¼"'
752	n/a	mock.source = source.encode('utf-8')
753	n/a	returned_source = mock.get_source(name)
754	n/a	self.assertEqual(returned_source, source)
755	n/a
756	n/a	def test_decoded_source(self):
757	n/a	# Decoding should work.
758	n/a	name = 'mod'
759	n/a	mock = SourceOnlyLoaderMock("mod.file")
760	n/a	source = "# coding: Latin-1\nx='Ã¼'"
761	n/a	assert source.encode('latin-1') != source.encode('utf-8')
762	n/a	mock.source = source.encode('latin-1')
763	n/a	returned_source = mock.get_source(name)
764	n/a	self.assertEqual(returned_source, source)
765	n/a
766	n/a	def test_universal_newlines(self):
767	n/a	# PEP 302 says universal newlines should be used.
768	n/a	name = 'mod'
769	n/a	mock = SourceOnlyLoaderMock('mod.file')
770	n/a	source = "x = 42\r\ny = -13\r\n"
771	n/a	mock.source = source.encode('utf-8')
772	n/a	expect = io.IncrementalNewlineDecoder(None, True).decode(source)
773	n/a	self.assertEqual(mock.get_source(name), expect)
774	n/a
775	n/a	class AbstractMethodImplTests(unittest.TestCase):
776	n/a
777	n/a	"""Test the concrete abstractmethod implementations."""
778	n/a
779	n/a	class Loader(abc.Loader):
780	n/a	def load_module(self, fullname):
781	n/a	super().load_module(fullname)
782	n/a
783	n/a	class Finder(abc.Finder):
784	n/a	def find_module(self, _):
785	n/a	super().find_module(_)
786	n/a
787	n/a	class ResourceLoader(Loader, abc.ResourceLoader):
788	n/a	def get_data(self, _):
789	n/a	super().get_data(_)
790	n/a
791	n/a	class InspectLoader(Loader, abc.InspectLoader):
792	n/a	def is_package(self, _):
793	n/a	super().is_package(_)
794	n/a
795	n/a	def get_code(self, _):
796	n/a	super().get_code(_)
797	n/a
798	n/a	def get_source(self, _):
799	n/a	super().get_source(_)
800	n/a
801	n/a	class ExecutionLoader(InspectLoader, abc.ExecutionLoader):
802	n/a	def get_filename(self, _):
803	n/a	super().get_filename(_)
804	n/a
805	n/a	class SourceLoader(ResourceLoader, ExecutionLoader, abc.SourceLoader):
806	n/a	pass
807	n/a
808	n/a	class PyLoader(ResourceLoader, InspectLoader, abc.PyLoader):
809	n/a	def source_path(self, _):
810	n/a	super().source_path(_)
811	n/a
812	n/a	class PyPycLoader(PyLoader, abc.PyPycLoader):
813	n/a	def bytecode_path(self, _):
814	n/a	super().bytecode_path(_)
815	n/a
816	n/a	def source_mtime(self, _):
817	n/a	super().source_mtime(_)
818	n/a
819	n/a	def write_bytecode(self, _, _2):
820	n/a	super().write_bytecode(_, _2)
821	n/a
822	n/a	def raises_NotImplementedError(self, ins, *args):
823	n/a	for method_name in args:
824	n/a	method = getattr(ins, method_name)
825	n/a	arg_count = len(inspect.getfullargspec(method)[0]) - 1
826	n/a	args = [''] * arg_count
827	n/a	try:
828	n/a	method(*args)
829	n/a	except NotImplementedError:
830	n/a	pass
831	n/a	else:
832	n/a	msg = "{}.{} did not raise NotImplementedError"
833	n/a	self.fail(msg.format(ins.__class__.__name__, method_name))
834	n/a
835	n/a	def test_Loader(self):
836	n/a	self.raises_NotImplementedError(self.Loader(), 'load_module')
837	n/a
838	n/a	# XXX misplaced; should be somewhere else
839	n/a	def test_Finder(self):
840	n/a	self.raises_NotImplementedError(self.Finder(), 'find_module')
841	n/a
842	n/a	def test_ResourceLoader(self):
843	n/a	self.raises_NotImplementedError(self.ResourceLoader(), 'load_module',
844	n/a	'get_data')
845	n/a
846	n/a	def test_InspectLoader(self):
847	n/a	self.raises_NotImplementedError(self.InspectLoader(), 'load_module',
848	n/a	'is_package', 'get_code', 'get_source')
849	n/a
850	n/a	def test_ExecutionLoader(self):
851	n/a	self.raises_NotImplementedError(self.ExecutionLoader(), 'load_module',
852	n/a	'is_package', 'get_code', 'get_source',
853	n/a	'get_filename')
854	n/a
855	n/a	def test_SourceLoader(self):
856	n/a	ins = self.SourceLoader()
857	n/a	# Required abstractmethods.
858	n/a	self.raises_NotImplementedError(ins, 'get_filename', 'get_data')
859	n/a	# Optional abstractmethods.
860	n/a	self.raises_NotImplementedError(ins,'path_stats', 'set_data')
861	n/a
862	n/a	def test_PyLoader(self):
863	n/a	self.raises_NotImplementedError(self.PyLoader(), 'source_path',
864	n/a	'get_data', 'is_package')
865	n/a
866	n/a	def test_PyPycLoader(self):
867	n/a	self.raises_NotImplementedError(self.PyPycLoader(), 'source_path',
868	n/a	'source_mtime', 'bytecode_path',
869	n/a	'write_bytecode')
870	n/a
871	n/a
872	n/a	def test_main():
873	n/a	from test.support import run_unittest
874	n/a	run_unittest(PyLoaderTests, PyLoaderCompatTests,
875	n/a	PyLoaderInterfaceTests,
876	n/a	PyPycLoaderTests, PyPycLoaderInterfaceTests,
877	n/a	SkipWritingBytecodeTests, RegeneratedBytecodeTests,
878	n/a	BadBytecodeFailureTests, MissingPathsTests,
879	n/a	SourceOnlyLoaderTests,
880	n/a	SourceLoaderBytecodeTests,
881	n/a	SourceLoaderGetSourceTests,
882	n/a	AbstractMethodImplTests)
883	n/a
884	n/a
885	n/a	if __name__ == '__main__':
886	n/a	test_main()