Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 1 | # Test the module type |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 2 | import unittest |
Antoine Pitrou | 4ed328c | 2013-08-01 19:20:31 +0200 | [diff] [blame] | 3 | import weakref |
Zachary Ware | 38c707e | 2015-04-13 15:00:43 -0500 | [diff] [blame] | 4 | from test.support import gc_collect |
Berker Peksag | ce64391 | 2015-05-06 06:33:17 +0300 | [diff] [blame] | 5 | from test.support.script_helper import assert_python_ok |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 6 | |
| 7 | import sys |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 8 | ModuleType = type(sys) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 9 | |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 10 | class FullLoader: |
| 11 | @classmethod |
| 12 | def module_repr(cls, m): |
| 13 | return "<module '{}' (crafted)>".format(m.__name__) |
| 14 | |
| 15 | class BareLoader: |
| 16 | pass |
| 17 | |
| 18 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 19 | class ModuleTests(unittest.TestCase): |
| 20 | def test_uninitialized(self): |
| 21 | # An uninitialized module has no __dict__ or __name__, |
| 22 | # and __doc__ is None |
| 23 | foo = ModuleType.__new__(ModuleType) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 24 | self.assertTrue(foo.__dict__ is None) |
Benjamin Peterson | 1432771 | 2009-08-15 13:23:05 +0000 | [diff] [blame] | 25 | self.assertRaises(SystemError, dir, foo) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 26 | try: |
| 27 | s = foo.__name__ |
| 28 | self.fail("__name__ = %s" % repr(s)) |
| 29 | except AttributeError: |
| 30 | pass |
| 31 | self.assertEqual(foo.__doc__, ModuleType.__doc__) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 32 | |
Ethan Furman | 7b9ff0e | 2014-04-24 14:47:47 -0700 | [diff] [blame] | 33 | def test_unintialized_missing_getattr(self): |
| 34 | # Issue 8297 |
| 35 | # test the text in the AttributeError of an uninitialized module |
| 36 | foo = ModuleType.__new__(ModuleType) |
| 37 | self.assertRaisesRegex( |
| 38 | AttributeError, "module has no attribute 'not_here'", |
| 39 | getattr, foo, "not_here") |
| 40 | |
| 41 | def test_missing_getattr(self): |
| 42 | # Issue 8297 |
| 43 | # test the text in the AttributeError |
| 44 | foo = ModuleType("foo") |
| 45 | self.assertRaisesRegex( |
| 46 | AttributeError, "module 'foo' has no attribute 'not_here'", |
| 47 | getattr, foo, "not_here") |
| 48 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 49 | def test_no_docstring(self): |
| 50 | # Regularly initialized module, no docstring |
| 51 | foo = ModuleType("foo") |
| 52 | self.assertEqual(foo.__name__, "foo") |
| 53 | self.assertEqual(foo.__doc__, None) |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 54 | self.assertIs(foo.__loader__, None) |
| 55 | self.assertIs(foo.__package__, None) |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 56 | self.assertIs(foo.__spec__, None) |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 57 | self.assertEqual(foo.__dict__, {"__name__": "foo", "__doc__": None, |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 58 | "__loader__": None, "__package__": None, |
| 59 | "__spec__": None}) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 60 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 61 | def test_ascii_docstring(self): |
| 62 | # ASCII docstring |
| 63 | foo = ModuleType("foo", "foodoc") |
| 64 | self.assertEqual(foo.__name__, "foo") |
| 65 | self.assertEqual(foo.__doc__, "foodoc") |
| 66 | self.assertEqual(foo.__dict__, |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 67 | {"__name__": "foo", "__doc__": "foodoc", |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 68 | "__loader__": None, "__package__": None, |
| 69 | "__spec__": None}) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 70 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 71 | def test_unicode_docstring(self): |
| 72 | # Unicode docstring |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 73 | foo = ModuleType("foo", "foodoc\u1234") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 74 | self.assertEqual(foo.__name__, "foo") |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 75 | self.assertEqual(foo.__doc__, "foodoc\u1234") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 76 | self.assertEqual(foo.__dict__, |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 77 | {"__name__": "foo", "__doc__": "foodoc\u1234", |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 78 | "__loader__": None, "__package__": None, |
| 79 | "__spec__": None}) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 80 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 81 | def test_reinit(self): |
| 82 | # Reinitialization should not replace the __dict__ |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 83 | foo = ModuleType("foo", "foodoc\u1234") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 84 | foo.bar = 42 |
| 85 | d = foo.__dict__ |
| 86 | foo.__init__("foo", "foodoc") |
| 87 | self.assertEqual(foo.__name__, "foo") |
| 88 | self.assertEqual(foo.__doc__, "foodoc") |
| 89 | self.assertEqual(foo.bar, 42) |
| 90 | self.assertEqual(foo.__dict__, |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 91 | {"__name__": "foo", "__doc__": "foodoc", "bar": 42, |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 92 | "__loader__": None, "__package__": None, "__spec__": None}) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 93 | self.assertTrue(foo.__dict__ is d) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 94 | |
Benjamin Peterson | a0dfa82 | 2009-11-13 02:25:08 +0000 | [diff] [blame] | 95 | def test_dont_clear_dict(self): |
| 96 | # See issue 7140. |
| 97 | def f(): |
| 98 | foo = ModuleType("foo") |
| 99 | foo.bar = 4 |
| 100 | return foo |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 101 | gc_collect() |
Benjamin Peterson | a0dfa82 | 2009-11-13 02:25:08 +0000 | [diff] [blame] | 102 | self.assertEqual(f().__dict__["bar"], 4) |
| 103 | |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 104 | def test_clear_dict_in_ref_cycle(self): |
| 105 | destroyed = [] |
| 106 | m = ModuleType("foo") |
| 107 | m.destroyed = destroyed |
| 108 | s = """class A: |
Benjamin Peterson | ca81bf7 | 2011-12-15 15:57:15 -0500 | [diff] [blame] | 109 | def __init__(self, l): |
| 110 | self.l = l |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 111 | def __del__(self): |
Benjamin Peterson | ca81bf7 | 2011-12-15 15:57:15 -0500 | [diff] [blame] | 112 | self.l.append(1) |
| 113 | a = A(destroyed)""" |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 114 | exec(s, m.__dict__) |
| 115 | del m |
| 116 | gc_collect() |
| 117 | self.assertEqual(destroyed, [1]) |
| 118 | |
Antoine Pitrou | 4ed328c | 2013-08-01 19:20:31 +0200 | [diff] [blame] | 119 | def test_weakref(self): |
| 120 | m = ModuleType("foo") |
| 121 | wr = weakref.ref(m) |
| 122 | self.assertIs(wr(), m) |
| 123 | del m |
| 124 | gc_collect() |
| 125 | self.assertIs(wr(), None) |
| 126 | |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 127 | def test_module_repr_minimal(self): |
| 128 | # reprs when modules have no __file__, __name__, or __loader__ |
| 129 | m = ModuleType('foo') |
| 130 | del m.__name__ |
| 131 | self.assertEqual(repr(m), "<module '?'>") |
| 132 | |
| 133 | def test_module_repr_with_name(self): |
| 134 | m = ModuleType('foo') |
| 135 | self.assertEqual(repr(m), "<module 'foo'>") |
| 136 | |
| 137 | def test_module_repr_with_name_and_filename(self): |
| 138 | m = ModuleType('foo') |
| 139 | m.__file__ = '/tmp/foo.py' |
| 140 | self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>") |
| 141 | |
| 142 | def test_module_repr_with_filename_only(self): |
| 143 | m = ModuleType('foo') |
| 144 | del m.__name__ |
| 145 | m.__file__ = '/tmp/foo.py' |
| 146 | self.assertEqual(repr(m), "<module '?' from '/tmp/foo.py'>") |
| 147 | |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 148 | def test_module_repr_with_loader_as_None(self): |
| 149 | m = ModuleType('foo') |
| 150 | assert m.__loader__ is None |
| 151 | self.assertEqual(repr(m), "<module 'foo'>") |
| 152 | |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 153 | def test_module_repr_with_bare_loader_but_no_name(self): |
| 154 | m = ModuleType('foo') |
| 155 | del m.__name__ |
| 156 | # Yes, a class not an instance. |
| 157 | m.__loader__ = BareLoader |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 158 | loader_repr = repr(BareLoader) |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 159 | self.assertEqual( |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 160 | repr(m), "<module '?' ({})>".format(loader_repr)) |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 161 | |
| 162 | def test_module_repr_with_full_loader_but_no_name(self): |
| 163 | # m.__loader__.module_repr() will fail because the module has no |
| 164 | # m.__name__. This exception will get suppressed and instead the |
| 165 | # loader's repr will be used. |
| 166 | m = ModuleType('foo') |
| 167 | del m.__name__ |
| 168 | # Yes, a class not an instance. |
| 169 | m.__loader__ = FullLoader |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 170 | loader_repr = repr(FullLoader) |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 171 | self.assertEqual( |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 172 | repr(m), "<module '?' ({})>".format(loader_repr)) |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 173 | |
| 174 | def test_module_repr_with_bare_loader(self): |
| 175 | m = ModuleType('foo') |
| 176 | # Yes, a class not an instance. |
| 177 | m.__loader__ = BareLoader |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 178 | module_repr = repr(BareLoader) |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 179 | self.assertEqual( |
Brett Cannon | 4c14b5d | 2013-05-04 13:56:58 -0400 | [diff] [blame] | 180 | repr(m), "<module 'foo' ({})>".format(module_repr)) |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 181 | |
| 182 | def test_module_repr_with_full_loader(self): |
| 183 | m = ModuleType('foo') |
| 184 | # Yes, a class not an instance. |
| 185 | m.__loader__ = FullLoader |
| 186 | self.assertEqual( |
| 187 | repr(m), "<module 'foo' (crafted)>") |
| 188 | |
| 189 | def test_module_repr_with_bare_loader_and_filename(self): |
| 190 | # Because the loader has no module_repr(), use the file name. |
| 191 | m = ModuleType('foo') |
| 192 | # Yes, a class not an instance. |
| 193 | m.__loader__ = BareLoader |
| 194 | m.__file__ = '/tmp/foo.py' |
| 195 | self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>") |
| 196 | |
| 197 | def test_module_repr_with_full_loader_and_filename(self): |
| 198 | # Even though the module has an __file__, use __loader__.module_repr() |
| 199 | m = ModuleType('foo') |
| 200 | # Yes, a class not an instance. |
| 201 | m.__loader__ = FullLoader |
| 202 | m.__file__ = '/tmp/foo.py' |
| 203 | self.assertEqual(repr(m), "<module 'foo' (crafted)>") |
| 204 | |
| 205 | def test_module_repr_builtin(self): |
| 206 | self.assertEqual(repr(sys), "<module 'sys' (built-in)>") |
| 207 | |
| 208 | def test_module_repr_source(self): |
| 209 | r = repr(unittest) |
Brett Cannon | a24348c | 2013-11-22 13:22:22 -0500 | [diff] [blame] | 210 | starts_with = "<module 'unittest' from '" |
| 211 | ends_with = "__init__.py'>" |
| 212 | self.assertEqual(r[:len(starts_with)], starts_with, |
| 213 | '{!r} does not start with {!r}'.format(r, starts_with)) |
| 214 | self.assertEqual(r[-len(ends_with):], ends_with, |
| 215 | '{!r} does not end with {!r}'.format(r, ends_with)) |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 216 | |
Antoine Pitrou | dcedaf6 | 2013-07-31 23:14:08 +0200 | [diff] [blame] | 217 | def test_module_finalization_at_shutdown(self): |
| 218 | # Module globals and builtins should still be available during shutdown |
| 219 | rc, out, err = assert_python_ok("-c", "from test import final_a") |
| 220 | self.assertFalse(err) |
| 221 | lines = out.splitlines() |
| 222 | self.assertEqual(set(lines), { |
| 223 | b"x = a", |
| 224 | b"x = b", |
| 225 | b"final_a.x = a", |
| 226 | b"final_b.x = b", |
| 227 | b"len = len", |
| 228 | b"shutil.rmtree = rmtree"}) |
| 229 | |
Benjamin Peterson | 1184e26 | 2014-04-24 19:29:23 -0400 | [diff] [blame] | 230 | def test_descriptor_errors_propogate(self): |
| 231 | class Descr: |
| 232 | def __get__(self, o, t): |
| 233 | raise RuntimeError |
| 234 | class M(ModuleType): |
| 235 | melon = Descr() |
| 236 | self.assertRaises(RuntimeError, getattr, M("mymod"), "melon") |
| 237 | |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 238 | # frozen and namespace module reprs are tested in importlib. |
| 239 | |
| 240 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 241 | if __name__ == '__main__': |
Zachary Ware | 38c707e | 2015-04-13 15:00:43 -0500 | [diff] [blame] | 242 | unittest.main() |