Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 1 | from .. import abc |
Brett Cannon | bcb26c5 | 2009-02-01 04:00:05 +0000 | [diff] [blame] | 2 | from .. import util |
Brett Cannon | ef88802 | 2013-06-15 18:39:21 -0400 | [diff] [blame] | 3 | |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 4 | machinery = util.import_importlib('importlib.machinery') |
| 5 | |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 6 | |
| 7 | import sys |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 8 | from test.support import captured_stdout |
Brett Cannon | ef88802 | 2013-06-15 18:39:21 -0400 | [diff] [blame] | 9 | import types |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 10 | import unittest |
Eric Snow | 1500d49 | 2014-01-06 20:49:04 -0700 | [diff] [blame] | 11 | import warnings |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 12 | |
| 13 | |
| 14 | class ExecModuleTests(abc.LoaderTests): |
| 15 | |
| 16 | def exec_module(self, name): |
| 17 | with util.uncache(name), captured_stdout() as stdout: |
| 18 | spec = self.machinery.ModuleSpec( |
| 19 | name, self.machinery.FrozenImporter, origin='frozen', |
| 20 | is_package=self.machinery.FrozenImporter.is_package(name)) |
| 21 | module = types.ModuleType(name) |
| 22 | module.__spec__ = spec |
| 23 | assert not hasattr(module, 'initialized') |
| 24 | self.machinery.FrozenImporter.exec_module(module) |
| 25 | self.assertTrue(module.initialized) |
| 26 | self.assertTrue(hasattr(module, '__spec__')) |
| 27 | self.assertEqual(module.__spec__.origin, 'frozen') |
| 28 | return module, stdout.getvalue() |
| 29 | |
| 30 | def test_module(self): |
| 31 | name = '__hello__' |
| 32 | module, output = self.exec_module(name) |
| 33 | check = {'__name__': name} |
| 34 | for attr, value in check.items(): |
| 35 | self.assertEqual(getattr(module, attr), value) |
| 36 | self.assertEqual(output, 'Hello world!\n') |
| 37 | self.assertTrue(hasattr(module, '__spec__')) |
| 38 | |
| 39 | def test_package(self): |
| 40 | name = '__phello__' |
| 41 | module, output = self.exec_module(name) |
| 42 | check = {'__name__': name} |
| 43 | for attr, value in check.items(): |
| 44 | attr_value = getattr(module, attr) |
| 45 | self.assertEqual(attr_value, value, |
| 46 | 'for {name}.{attr}, {given!r} != {expected!r}'.format( |
| 47 | name=name, attr=attr, given=attr_value, |
| 48 | expected=value)) |
| 49 | self.assertEqual(output, 'Hello world!\n') |
| 50 | |
| 51 | def test_lacking_parent(self): |
| 52 | name = '__phello__.spam' |
| 53 | with util.uncache('__phello__'): |
| 54 | module, output = self.exec_module(name) |
| 55 | check = {'__name__': name} |
| 56 | for attr, value in check.items(): |
| 57 | attr_value = getattr(module, attr) |
| 58 | self.assertEqual(attr_value, value, |
| 59 | 'for {name}.{attr}, {given} != {expected!r}'.format( |
| 60 | name=name, attr=attr, given=attr_value, |
| 61 | expected=value)) |
| 62 | self.assertEqual(output, 'Hello world!\n') |
| 63 | |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 64 | def test_module_repr(self): |
| 65 | name = '__hello__' |
| 66 | module, output = self.exec_module(name) |
Eric Snow | 1500d49 | 2014-01-06 20:49:04 -0700 | [diff] [blame] | 67 | with warnings.catch_warnings(): |
| 68 | warnings.simplefilter('ignore', DeprecationWarning) |
| 69 | repr_str = self.machinery.FrozenImporter.module_repr(module) |
| 70 | self.assertEqual(repr_str, |
| 71 | "<module '__hello__' (frozen)>") |
| 72 | |
| 73 | def test_module_repr_indirect(self): |
| 74 | name = '__hello__' |
| 75 | module, output = self.exec_module(name) |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 76 | self.assertEqual(repr(module), |
| 77 | "<module '__hello__' (frozen)>") |
| 78 | |
| 79 | # No way to trigger an error in a frozen module. |
| 80 | test_state_after_failure = None |
| 81 | |
| 82 | def test_unloadable(self): |
| 83 | assert self.machinery.FrozenImporter.find_module('_not_real') is None |
| 84 | with self.assertRaises(ImportError) as cm: |
| 85 | self.exec_module('_not_real') |
| 86 | self.assertEqual(cm.exception.name, '_not_real') |
| 87 | |
| 88 | Frozen_ExecModuleTests, Source_ExecModuleTests = util.test_both(ExecModuleTests, |
| 89 | machinery=machinery) |
Brett Cannon | ef88802 | 2013-06-15 18:39:21 -0400 | [diff] [blame] | 90 | |
Brett Cannon | 23cbd8a | 2009-01-18 00:24:28 +0000 | [diff] [blame] | 91 | |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 92 | class LoaderTests(abc.LoaderTests): |
Brett Cannon | 23cbd8a | 2009-01-18 00:24:28 +0000 | [diff] [blame] | 93 | |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 94 | def test_module(self): |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 95 | with util.uncache('__hello__'), captured_stdout() as stdout: |
Eric Snow | 1500d49 | 2014-01-06 20:49:04 -0700 | [diff] [blame] | 96 | with warnings.catch_warnings(): |
| 97 | warnings.simplefilter('ignore', DeprecationWarning) |
| 98 | module = self.machinery.FrozenImporter.load_module('__hello__') |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 99 | check = {'__name__': '__hello__', |
Eric V. Smith | 283d0ba | 2012-05-24 20:22:10 -0400 | [diff] [blame] | 100 | '__package__': '', |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 101 | '__loader__': self.machinery.FrozenImporter, |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 102 | } |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 103 | for attr, value in check.items(): |
| 104 | self.assertEqual(getattr(module, attr), value) |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 105 | self.assertEqual(stdout.getvalue(), 'Hello world!\n') |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 106 | self.assertFalse(hasattr(module, '__file__')) |
Brett Cannon | 23cbd8a | 2009-01-18 00:24:28 +0000 | [diff] [blame] | 107 | |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 108 | def test_package(self): |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 109 | with util.uncache('__phello__'), captured_stdout() as stdout: |
Eric Snow | 1500d49 | 2014-01-06 20:49:04 -0700 | [diff] [blame] | 110 | with warnings.catch_warnings(): |
| 111 | warnings.simplefilter('ignore', DeprecationWarning) |
| 112 | module = self.machinery.FrozenImporter.load_module('__phello__') |
Eric V. Smith | 283d0ba | 2012-05-24 20:22:10 -0400 | [diff] [blame] | 113 | check = {'__name__': '__phello__', |
| 114 | '__package__': '__phello__', |
Brett Cannon | 3e0651b | 2013-05-31 23:18:39 -0400 | [diff] [blame] | 115 | '__path__': [], |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 116 | '__loader__': self.machinery.FrozenImporter, |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 117 | } |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 118 | for attr, value in check.items(): |
| 119 | attr_value = getattr(module, attr) |
| 120 | self.assertEqual(attr_value, value, |
| 121 | "for __phello__.%s, %r != %r" % |
| 122 | (attr, attr_value, value)) |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 123 | self.assertEqual(stdout.getvalue(), 'Hello world!\n') |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 124 | self.assertFalse(hasattr(module, '__file__')) |
Brett Cannon | 23cbd8a | 2009-01-18 00:24:28 +0000 | [diff] [blame] | 125 | |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 126 | def test_lacking_parent(self): |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 127 | with util.uncache('__phello__', '__phello__.spam'), \ |
| 128 | captured_stdout() as stdout: |
Eric Snow | 1500d49 | 2014-01-06 20:49:04 -0700 | [diff] [blame] | 129 | with warnings.catch_warnings(): |
| 130 | warnings.simplefilter('ignore', DeprecationWarning) |
| 131 | module = self.machinery.FrozenImporter.load_module('__phello__.spam') |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 132 | check = {'__name__': '__phello__.spam', |
Brett Cannon | 2cf03a8 | 2009-03-10 05:17:37 +0000 | [diff] [blame] | 133 | '__package__': '__phello__', |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 134 | '__loader__': self.machinery.FrozenImporter, |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 135 | } |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 136 | for attr, value in check.items(): |
| 137 | attr_value = getattr(module, attr) |
| 138 | self.assertEqual(attr_value, value, |
| 139 | "for __phello__.spam.%s, %r != %r" % |
| 140 | (attr, attr_value, value)) |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 141 | self.assertEqual(stdout.getvalue(), 'Hello world!\n') |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 142 | self.assertFalse(hasattr(module, '__file__')) |
Brett Cannon | 23cbd8a | 2009-01-18 00:24:28 +0000 | [diff] [blame] | 143 | |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 144 | def test_module_reuse(self): |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 145 | with util.uncache('__hello__'), captured_stdout() as stdout: |
Eric Snow | 1500d49 | 2014-01-06 20:49:04 -0700 | [diff] [blame] | 146 | with warnings.catch_warnings(): |
| 147 | warnings.simplefilter('ignore', DeprecationWarning) |
| 148 | module1 = self.machinery.FrozenImporter.load_module('__hello__') |
| 149 | module2 = self.machinery.FrozenImporter.load_module('__hello__') |
Eric V. Smith | faae3ad | 2012-06-27 15:26:26 -0400 | [diff] [blame] | 150 | self.assertIs(module1, module2) |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 151 | self.assertEqual(stdout.getvalue(), |
| 152 | 'Hello world!\nHello world!\n') |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 153 | |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 154 | def test_module_repr(self): |
| 155 | with util.uncache('__hello__'), captured_stdout(): |
Eric Snow | 1500d49 | 2014-01-06 20:49:04 -0700 | [diff] [blame] | 156 | with warnings.catch_warnings(): |
| 157 | warnings.simplefilter('ignore', DeprecationWarning) |
| 158 | module = self.machinery.FrozenImporter.load_module('__hello__') |
| 159 | repr_str = self.machinery.FrozenImporter.module_repr(module) |
| 160 | self.assertEqual(repr_str, |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 161 | "<module '__hello__' (frozen)>") |
| 162 | |
Eric Snow | 1500d49 | 2014-01-06 20:49:04 -0700 | [diff] [blame] | 163 | def test_module_repr_indirect(self): |
| 164 | with util.uncache('__hello__'), captured_stdout(): |
| 165 | module = self.machinery.FrozenImporter.load_module('__hello__') |
| 166 | self.assertEqual(repr(module), |
| 167 | "<module '__hello__' (frozen)>") |
| 168 | |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 169 | # No way to trigger an error in a frozen module. |
| 170 | test_state_after_failure = None |
Brett Cannon | 223a19d | 2009-02-01 01:34:13 +0000 | [diff] [blame] | 171 | |
| 172 | def test_unloadable(self): |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 173 | assert self.machinery.FrozenImporter.find_module('_not_real') is None |
Brett Cannon | bbb6680 | 2012-04-12 21:09:01 -0400 | [diff] [blame] | 174 | with self.assertRaises(ImportError) as cm: |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 175 | self.machinery.FrozenImporter.load_module('_not_real') |
Brett Cannon | bbb6680 | 2012-04-12 21:09:01 -0400 | [diff] [blame] | 176 | self.assertEqual(cm.exception.name, '_not_real') |
Brett Cannon | 23cbd8a | 2009-01-18 00:24:28 +0000 | [diff] [blame] | 177 | |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 178 | Frozen_LoaderTests, Source_LoaderTests = util.test_both(LoaderTests, |
| 179 | machinery=machinery) |
Brett Cannon | 23cbd8a | 2009-01-18 00:24:28 +0000 | [diff] [blame] | 180 | |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 181 | |
| 182 | class InspectLoaderTests: |
Brett Cannon | 8d11013 | 2009-03-15 02:20:16 +0000 | [diff] [blame] | 183 | |
| 184 | """Tests for the InspectLoader methods for FrozenImporter.""" |
| 185 | |
| 186 | def test_get_code(self): |
| 187 | # Make sure that the code object is good. |
| 188 | name = '__hello__' |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 189 | with captured_stdout() as stdout: |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 190 | code = self.machinery.FrozenImporter.get_code(name) |
Brett Cannon | ef88802 | 2013-06-15 18:39:21 -0400 | [diff] [blame] | 191 | mod = types.ModuleType(name) |
Victor Stinner | 272e243 | 2011-05-16 16:57:18 +0200 | [diff] [blame] | 192 | exec(code, mod.__dict__) |
| 193 | self.assertTrue(hasattr(mod, 'initialized')) |
| 194 | self.assertEqual(stdout.getvalue(), 'Hello world!\n') |
Brett Cannon | 8d11013 | 2009-03-15 02:20:16 +0000 | [diff] [blame] | 195 | |
| 196 | def test_get_source(self): |
| 197 | # Should always return None. |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 198 | result = self.machinery.FrozenImporter.get_source('__hello__') |
Eric V. Smith | b109515 | 2012-06-28 06:15:01 -0400 | [diff] [blame] | 199 | self.assertIsNone(result) |
Brett Cannon | 8d11013 | 2009-03-15 02:20:16 +0000 | [diff] [blame] | 200 | |
| 201 | def test_is_package(self): |
| 202 | # Should be able to tell what is a package. |
| 203 | test_for = (('__hello__', False), ('__phello__', True), |
| 204 | ('__phello__.spam', False)) |
| 205 | for name, is_package in test_for: |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 206 | result = self.machinery.FrozenImporter.is_package(name) |
Eric V. Smith | faae3ad | 2012-06-27 15:26:26 -0400 | [diff] [blame] | 207 | self.assertEqual(bool(result), is_package) |
Brett Cannon | 8d11013 | 2009-03-15 02:20:16 +0000 | [diff] [blame] | 208 | |
| 209 | def test_failure(self): |
| 210 | # Raise ImportError for modules that are not frozen. |
| 211 | for meth_name in ('get_code', 'get_source', 'is_package'): |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 212 | method = getattr(self.machinery.FrozenImporter, meth_name) |
Brett Cannon | bbb6680 | 2012-04-12 21:09:01 -0400 | [diff] [blame] | 213 | with self.assertRaises(ImportError) as cm: |
Brett Cannon | 2153dc0 | 2009-08-27 23:49:21 +0000 | [diff] [blame] | 214 | method('importlib') |
Brett Cannon | bbb6680 | 2012-04-12 21:09:01 -0400 | [diff] [blame] | 215 | self.assertEqual(cm.exception.name, 'importlib') |
Brett Cannon | 8d11013 | 2009-03-15 02:20:16 +0000 | [diff] [blame] | 216 | |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 217 | Frozen_ILTests, Source_ILTests = util.test_both(InspectLoaderTests, |
| 218 | machinery=machinery) |
Brett Cannon | 23cbd8a | 2009-01-18 00:24:28 +0000 | [diff] [blame] | 219 | |
| 220 | |
| 221 | if __name__ == '__main__': |
Brett Cannon | a3c6963 | 2013-11-08 11:10:41 -0500 | [diff] [blame] | 222 | unittest.main() |