Debian Codegraph @

Lib/test/test_module/__init__.py

raw
1 # Test the module type
2 import importlib.machinery
3 import unittest
4 import weakref
5 from test.support import gc_collect
6 from test.support import import_helper
7 from test.support.script_helper import assert_python_ok
8
9 import sys
10 ModuleType = type(sys)
11
12
13 class FullLoader:
14 pass
15
16
17 class BareLoader:
18 pass
19
20
21 class ModuleTests(unittest.TestCase):
22 def test_uninitialized(self):
23 # An uninitialized module has no __dict__ or __name__,
24 # and __doc__ is None
25 foo = ModuleType.__new__(ModuleType)
26 self.assertTrue(isinstance(foo.__dict__, dict))
27 self.assertEqual(dir(foo), [])
28 try:
29 s = foo.__name__
30 self.fail("__name__ = %s" % repr(s))
31 except AttributeError:
32 pass
33 self.assertEqual(foo.__doc__, ModuleType.__doc__ or '')
34
35 def test_uninitialized_missing_getattr(self):
36 # Issue 8297
37 # test the text in the AttributeError of an uninitialized module
38 foo = ModuleType.__new__(ModuleType)
39 self.assertRaisesRegex(
40 AttributeError, "module has no attribute 'not_here'",
41 getattr, foo, "not_here")
42
43 def test_missing_getattr(self):
44 # Issue 8297
45 # test the text in the AttributeError
46 foo = ModuleType("foo")
47 self.assertRaisesRegex(
48 AttributeError, "module 'foo' has no attribute 'not_here'",
49 getattr, foo, "not_here")
50
51 def test_no_docstring(self):
52 # Regularly initialized module, no docstring
53 foo = ModuleType("foo")
54 self.assertEqual(foo.__name__, "foo")
55 self.assertEqual(foo.__doc__, None)
56 self.assertIs(foo.__loader__, None)
57 self.assertIs(foo.__package__, None)
58 self.assertIs(foo.__spec__, None)
59 self.assertEqual(foo.__dict__, {"__name__": "foo", "__doc__": None,
60 "__loader__": None, "__package__": None,
61 "__spec__": None})
62
63 def test_ascii_docstring(self):
64 # ASCII docstring
65 foo = ModuleType("foo", "foodoc")
66 self.assertEqual(foo.__name__, "foo")
67 self.assertEqual(foo.__doc__, "foodoc")
68 self.assertEqual(foo.__dict__,
69 {"__name__": "foo", "__doc__": "foodoc",
70 "__loader__": None, "__package__": None,
71 "__spec__": None})
72
73 def test_unicode_docstring(self):
74 # Unicode docstring
75 foo = ModuleType("foo", "foodoc\u1234")
76 self.assertEqual(foo.__name__, "foo")
77 self.assertEqual(foo.__doc__, "foodoc\u1234")
78 self.assertEqual(foo.__dict__,
79 {"__name__": "foo", "__doc__": "foodoc\u1234",
80 "__loader__": None, "__package__": None,
81 "__spec__": None})
82
83 def test_reinit(self):
84 # Reinitialization should not replace the __dict__
85 foo = ModuleType("foo", "foodoc\u1234")
86 foo.bar = 42
87 d = foo.__dict__
88 foo.__init__("foo", "foodoc")
89 self.assertEqual(foo.__name__, "foo")
90 self.assertEqual(foo.__doc__, "foodoc")
91 self.assertEqual(foo.bar, 42)
92 self.assertEqual(foo.__dict__,
93 {"__name__": "foo", "__doc__": "foodoc", "bar": 42,
94 "__loader__": None, "__package__": None, "__spec__": None})
95 self.assertTrue(foo.__dict__ is d)
96
97 def test_dont_clear_dict(self):
98 # See issue 7140.
99 def f():
100 foo = ModuleType("foo")
101 foo.bar = 4
102 return foo
103 gc_collect()
104 self.assertEqual(f().__dict__["bar"], 4)
105
106 def test_clear_dict_in_ref_cycle(self):
107 destroyed = []
108 m = ModuleType("foo")
109 m.destroyed = destroyed
110 s = """class A:
111 def __init__(self, l):
112 self.l = l
113 def __del__(self):
114 self.l.append(1)
115 a = A(destroyed)"""
116 exec(s, m.__dict__)
117 del m
118 gc_collect()
119 self.assertEqual(destroyed, [1])
120
121 def test_weakref(self):
122 m = ModuleType("foo")
123 wr = weakref.ref(m)
124 self.assertIs(wr(), m)
125 del m
126 gc_collect()
127 self.assertIs(wr(), None)
128
129 def test_module_getattr(self):
130 import test.test_module.good_getattr as gga
131 from test.test_module.good_getattr import test
132 self.assertEqual(test, "There is test")
133 self.assertEqual(gga.x, 1)
134 self.assertEqual(gga.y, 2)
135 with self.assertRaisesRegex(AttributeError,
136 "Deprecated, use whatever instead"):
137 gga.yolo
138 self.assertEqual(gga.whatever, "There is whatever")
139 del sys.modules['test.test_module.good_getattr']
140
141 def test_module_getattr_errors(self):
142 import test.test_module.bad_getattr as bga
143 from test.test_module import bad_getattr2
144 self.assertEqual(bga.x, 1)
145 self.assertEqual(bad_getattr2.x, 1)
146 with self.assertRaises(TypeError):
147 bga.nope
148 with self.assertRaises(TypeError):
149 bad_getattr2.nope
150 del sys.modules['test.test_module.bad_getattr']
151 if 'test.test_module.bad_getattr2' in sys.modules:
152 del sys.modules['test.test_module.bad_getattr2']
153
154 def test_module_dir(self):
155 import test.test_module.good_getattr as gga
156 self.assertEqual(dir(gga), ['a', 'b', 'c'])
157 del sys.modules['test.test_module.good_getattr']
158
159 def test_module_dir_errors(self):
160 import test.test_module.bad_getattr as bga
161 from test.test_module import bad_getattr2
162 with self.assertRaises(TypeError):
163 dir(bga)
164 with self.assertRaises(TypeError):
165 dir(bad_getattr2)
166 del sys.modules['test.test_module.bad_getattr']
167 if 'test.test_module.bad_getattr2' in sys.modules:
168 del sys.modules['test.test_module.bad_getattr2']
169
170 def test_module_getattr_tricky(self):
171 from test.test_module import bad_getattr3
172 # these lookups should not crash
173 with self.assertRaises(AttributeError):
174 bad_getattr3.one
175 with self.assertRaises(AttributeError):
176 bad_getattr3.delgetattr
177 if 'test.test_module.bad_getattr3' in sys.modules:
178 del sys.modules['test.test_module.bad_getattr3']
179
180 def test_module_repr_minimal(self):
181 # reprs when modules have no __file__, __name__, or __loader__
182 m = ModuleType('foo')
183 del m.__name__
184 self.assertEqual(repr(m), "<module '?'>")
185
186 def test_module_repr_with_name(self):
187 m = ModuleType('foo')
188 self.assertEqual(repr(m), "<module 'foo'>")
189
190 def test_module_repr_with_name_and_filename(self):
191 m = ModuleType('foo')
192 m.__file__ = '/tmp/foo.py'
193 self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>")
194
195 def test_module_repr_with_filename_only(self):
196 m = ModuleType('foo')
197 del m.__name__
198 m.__file__ = '/tmp/foo.py'
199 self.assertEqual(repr(m), "<module '?' from '/tmp/foo.py'>")
200
201 def test_module_repr_with_loader_as_None(self):
202 m = ModuleType('foo')
203 assert m.__loader__ is None
204 self.assertEqual(repr(m), "<module 'foo'>")
205
206 def test_module_repr_with_bare_loader_but_no_name(self):
207 m = ModuleType('foo')
208 del m.__name__
209 # Yes, a class not an instance.
210 m.__loader__ = BareLoader
211 loader_repr = repr(BareLoader)
212 self.assertEqual(
213 repr(m), "<module '?' ({})>".format(loader_repr))
214
215 def test_module_repr_with_full_loader_but_no_name(self):
216 # m.__loader__.module_repr() will fail because the module has no
217 # m.__name__. This exception will get suppressed and instead the
218 # loader's repr will be used.
219 m = ModuleType('foo')
220 del m.__name__
221 # Yes, a class not an instance.
222 m.__loader__ = FullLoader
223 loader_repr = repr(FullLoader)
224 self.assertEqual(
225 repr(m), "<module '?' ({})>".format(loader_repr))
226
227 def test_module_repr_with_bare_loader(self):
228 m = ModuleType('foo')
229 # Yes, a class not an instance.
230 m.__loader__ = BareLoader
231 module_repr = repr(BareLoader)
232 self.assertEqual(
233 repr(m), "<module 'foo' ({})>".format(module_repr))
234
235 def test_module_repr_with_full_loader(self):
236 m = ModuleType('foo')
237 # Yes, a class not an instance.
238 m.__loader__ = FullLoader
239 self.assertEqual(
240 repr(m), f"<module 'foo' (<class '{__name__}.FullLoader'>)>")
241
242 def test_module_repr_with_bare_loader_and_filename(self):
243 m = ModuleType('foo')
244 # Yes, a class not an instance.
245 m.__loader__ = BareLoader
246 m.__file__ = '/tmp/foo.py'
247 self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>")
248
249 def test_module_repr_with_full_loader_and_filename(self):
250 m = ModuleType('foo')
251 # Yes, a class not an instance.
252 m.__loader__ = FullLoader
253 m.__file__ = '/tmp/foo.py'
254 self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>")
255
256 def test_module_repr_builtin(self):
257 self.assertEqual(repr(sys), "<module 'sys' (built-in)>")
258
259 def test_module_repr_source(self):
260 r = repr(unittest)
261 starts_with = "<module 'unittest' from '"
262 ends_with = "__init__.py'>"
263 self.assertEqual(r[:len(starts_with)], starts_with,
264 '{!r} does not start with {!r}'.format(r, starts_with))
265 self.assertEqual(r[-len(ends_with):], ends_with,
266 '{!r} does not end with {!r}'.format(r, ends_with))
267
268 def test_module_repr_with_namespace_package(self):
269 m = ModuleType('foo')
270 loader = importlib.machinery.NamespaceLoader('foo', ['bar'], 'baz')
271 spec = importlib.machinery.ModuleSpec('foo', loader)
272 m.__loader__ = loader
273 m.__spec__ = spec
274 self.assertEqual(repr(m), "<module 'foo' (namespace) from ['bar']>")
275
276 def test_module_repr_with_namespace_package_and_custom_loader(self):
277 m = ModuleType('foo')
278 loader = BareLoader()
279 spec = importlib.machinery.ModuleSpec('foo', loader)
280 m.__loader__ = loader
281 m.__spec__ = spec
282 expected_repr_pattern = r"<module 'foo' \(<.*\.BareLoader object at .+>\)>"
283 self.assertRegex(repr(m), expected_repr_pattern)
284 self.assertNotIn('from', repr(m))
285
286 def test_module_repr_with_fake_namespace_package(self):
287 m = ModuleType('foo')
288 loader = BareLoader()
289 loader._path = ['spam']
290 spec = importlib.machinery.ModuleSpec('foo', loader)
291 m.__loader__ = loader
292 m.__spec__ = spec
293 expected_repr_pattern = r"<module 'foo' \(<.*\.BareLoader object at .+>\)>"
294 self.assertRegex(repr(m), expected_repr_pattern)
295 self.assertNotIn('from', repr(m))
296
297 def test_module_finalization_at_shutdown(self):
298 # Module globals and builtins should still be available during shutdown
299 rc, out, err = assert_python_ok("-c", "from test.test_module import final_a")
300 self.assertFalse(err)
301 lines = out.splitlines()
302 self.assertEqual(set(lines), {
303 b"x = a",
304 b"x = b",
305 b"final_a.x = a",
306 b"final_b.x = b",
307 b"len = len",
308 b"shutil.rmtree = rmtree"})
309
310 def test_descriptor_errors_propagate(self):
311 class Descr:
312 def __get__(self, o, t):
313 raise RuntimeError
314 class M(ModuleType):
315 melon = Descr()
316 self.assertRaises(RuntimeError, getattr, M("mymod"), "melon")
317
318 def test_lazy_create_annotations(self):
319 # module objects lazy create their __annotations__ dict on demand.
320 # the annotations dict is stored in module.__dict__.
321 # a freshly created module shouldn't have an annotations dict yet.
322 foo = ModuleType("foo")
323 for i in range(4):
324 self.assertFalse("__annotations__" in foo.__dict__)
325 d = foo.__annotations__
326 self.assertTrue("__annotations__" in foo.__dict__)
327 self.assertEqual(foo.__annotations__, d)
328 self.assertEqual(foo.__dict__['__annotations__'], d)
329 if i % 2:
330 del foo.__annotations__
331 else:
332 del foo.__dict__['__annotations__']
333
334 def test_setting_annotations(self):
335 foo = ModuleType("foo")
336 for i in range(4):
337 self.assertFalse("__annotations__" in foo.__dict__)
338 d = {'a': int}
339 foo.__annotations__ = d
340 self.assertTrue("__annotations__" in foo.__dict__)
341 self.assertEqual(foo.__annotations__, d)
342 self.assertEqual(foo.__dict__['__annotations__'], d)
343 if i % 2:
344 del foo.__annotations__
345 else:
346 del foo.__dict__['__annotations__']
347
348 def test_annotations_getset_raises(self):
349 # double delete
350 foo = ModuleType("foo")
351 foo.__annotations__ = {}
352 del foo.__annotations__
353 with self.assertRaises(AttributeError):
354 del foo.__annotations__
355
356 def test_annotations_are_created_correctly(self):
357 ann_module4 = import_helper.import_fresh_module(
358 'test.typinganndata.ann_module4',
359 )
360 self.assertFalse("__annotations__" in ann_module4.__dict__)
361 self.assertEqual(ann_module4.__annotations__, {"a": int, "b": str})
362 self.assertTrue("__annotations__" in ann_module4.__dict__)
363 del ann_module4.__annotations__
364 self.assertFalse("__annotations__" in ann_module4.__dict__)
365
366
367 def test_repeated_attribute_pops(self):
368 # Repeated accesses to module attribute will be specialized
369 # Check that popping the attribute doesn't break it
370 m = ModuleType("test")
371 d = m.__dict__
372 count = 0
373 for _ in range(100):
374 m.attr = 1
375 count += m.attr # Might be specialized
376 d.pop("attr")
377 self.assertEqual(count, 100)
378
379 # frozen and namespace module reprs are tested in importlib.
380
381 def test_subclass_with_slots(self):
382 # In 3.11alpha this crashed, as the slots weren't NULLed.
383
384 class ModuleWithSlots(ModuleType):
385 __slots__ = ("a", "b")
386
387 def __init__(self, name):
388 super().__init__(name)
389
390 m = ModuleWithSlots("name")
391 with self.assertRaises(AttributeError):
392 m.a
393 with self.assertRaises(AttributeError):
394 m.b
395 m.a, m.b = 1, 2
396 self.assertEqual(m.a, 1)
397 self.assertEqual(m.b, 2)
398
399
400
401 if __name__ == '__main__':
402 unittest.main()