1 from test.test_importlib import abc, util
2
3 machinery = util.import_importlib('importlib.machinery')
4
5 from test.support import captured_stdout, import_helper, STDLIB_DIR
6 import _imp
7 import contextlib
8 import marshal
9 import os.path
10 import types
11 import unittest
12 import warnings
13
14
15 @contextlib.contextmanager
16 def deprecated():
17 with warnings.catch_warnings():
18 warnings.simplefilter('ignore', DeprecationWarning)
19 yield
20
21
22 @contextlib.contextmanager
23 def fresh(name, *, oldapi=False):
24 with util.uncache(name):
25 with import_helper.frozen_modules():
26 if oldapi:
27 with deprecated():
28 yield
29 else:
30 yield
31
32
33 def resolve_stdlib_file(name, ispkg=False):
34 assert name
35 if ispkg:
36 return os.path.join(STDLIB_DIR, *name.split('.'), '__init__.py')
37 else:
38 return os.path.join(STDLIB_DIR, *name.split('.')) + '.py'
39
40
41 class ESC[4;38;5;81mExecModuleTests(ESC[4;38;5;149mabcESC[4;38;5;149m.ESC[4;38;5;149mLoaderTests):
42
43 def exec_module(self, name, origname=None):
44 with import_helper.frozen_modules():
45 is_package = self.machinery.FrozenImporter.is_package(name)
46 spec = self.machinery.ModuleSpec(
47 name,
48 self.machinery.FrozenImporter,
49 origin='frozen',
50 is_package=is_package,
51 loader_state=types.SimpleNamespace(
52 origname=origname or name,
53 filename=resolve_stdlib_file(origname or name, is_package),
54 ),
55 )
56 module = types.ModuleType(name)
57 module.__spec__ = spec
58 assert not hasattr(module, 'initialized')
59
60 with fresh(name):
61 self.machinery.FrozenImporter.exec_module(module)
62 with captured_stdout() as stdout:
63 module.main()
64
65 self.assertTrue(module.initialized)
66 self.assertTrue(hasattr(module, '__spec__'))
67 self.assertEqual(module.__spec__.origin, 'frozen')
68 return module, stdout.getvalue()
69
70 def test_module(self):
71 name = '__hello__'
72 module, output = self.exec_module(name)
73 check = {'__name__': name}
74 for attr, value in check.items():
75 self.assertEqual(getattr(module, attr), value)
76 self.assertEqual(output, 'Hello world!\n')
77 self.assertTrue(hasattr(module, '__spec__'))
78 self.assertEqual(module.__spec__.loader_state.origname, name)
79
80 def test_package(self):
81 name = '__phello__'
82 module, output = self.exec_module(name)
83 check = {'__name__': name}
84 for attr, value in check.items():
85 attr_value = getattr(module, attr)
86 self.assertEqual(attr_value, value,
87 'for {name}.{attr}, {given!r} != {expected!r}'.format(
88 name=name, attr=attr, given=attr_value,
89 expected=value))
90 self.assertEqual(output, 'Hello world!\n')
91 self.assertEqual(module.__spec__.loader_state.origname, name)
92
93 def test_lacking_parent(self):
94 name = '__phello__.spam'
95 with util.uncache('__phello__'):
96 module, output = self.exec_module(name)
97 check = {'__name__': name}
98 for attr, value in check.items():
99 attr_value = getattr(module, attr)
100 self.assertEqual(attr_value, value,
101 'for {name}.{attr}, {given} != {expected!r}'.format(
102 name=name, attr=attr, given=attr_value,
103 expected=value))
104 self.assertEqual(output, 'Hello world!\n')
105
106 def test_module_repr_indirect_through_spec(self):
107 name = '__hello__'
108 module, output = self.exec_module(name)
109 self.assertEqual(repr(module),
110 "<module '__hello__' (frozen)>")
111
112 # No way to trigger an error in a frozen module.
113 test_state_after_failure = None
114
115 def test_unloadable(self):
116 with import_helper.frozen_modules():
117 assert self.machinery.FrozenImporter.find_spec('_not_real') is None
118 with self.assertRaises(ImportError) as cm:
119 self.exec_module('_not_real')
120 self.assertEqual(cm.exception.name, '_not_real')
121
122
123 (Frozen_ExecModuleTests,
124 Source_ExecModuleTests
125 ) = util.test_both(ExecModuleTests, machinery=machinery)
126
127
128 class ESC[4;38;5;81mInspectLoaderTests:
129
130 """Tests for the InspectLoader methods for FrozenImporter."""
131
132 def test_get_code(self):
133 # Make sure that the code object is good.
134 name = '__hello__'
135 with import_helper.frozen_modules():
136 code = self.machinery.FrozenImporter.get_code(name)
137 mod = types.ModuleType(name)
138 exec(code, mod.__dict__)
139 with captured_stdout() as stdout:
140 mod.main()
141 self.assertTrue(hasattr(mod, 'initialized'))
142 self.assertEqual(stdout.getvalue(), 'Hello world!\n')
143
144 def test_get_source(self):
145 # Should always return None.
146 with import_helper.frozen_modules():
147 result = self.machinery.FrozenImporter.get_source('__hello__')
148 self.assertIsNone(result)
149
150 def test_is_package(self):
151 # Should be able to tell what is a package.
152 test_for = (('__hello__', False), ('__phello__', True),
153 ('__phello__.spam', False))
154 for name, is_package in test_for:
155 with import_helper.frozen_modules():
156 result = self.machinery.FrozenImporter.is_package(name)
157 self.assertEqual(bool(result), is_package)
158
159 def test_failure(self):
160 # Raise ImportError for modules that are not frozen.
161 for meth_name in ('get_code', 'get_source', 'is_package'):
162 method = getattr(self.machinery.FrozenImporter, meth_name)
163 with self.assertRaises(ImportError) as cm:
164 with import_helper.frozen_modules():
165 method('importlib')
166 self.assertEqual(cm.exception.name, 'importlib')
167
168 (Frozen_ILTests,
169 Source_ILTests
170 ) = util.test_both(InspectLoaderTests, machinery=machinery)
171
172
173 if __name__ == '__main__':
174 unittest.main()