| 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() |