OLD | NEW |
1 # Test the runpy module | 1 # Test the runpy module |
2 import unittest | 2 import unittest |
3 import os | 3 import os |
4 import os.path | 4 import os.path |
5 import sys | 5 import sys |
6 import re | 6 import re |
7 import tempfile | 7 import tempfile |
8 from test.support import verbose, run_unittest, forget | 8 import py_compile |
9 from test.script_helper import (temp_dir, make_script, compile_script, | 9 from test.support import forget, make_legacy_pyc, run_unittest, verbose |
10 make_pkg, make_zip_script, make_zip_pkg) | 10 from test.script_helper import ( |
| 11 make_pkg, make_script, make_zip_pkg, make_zip_script, temp_dir) |
11 | 12 |
12 | 13 |
13 from runpy import _run_code, _run_module_code, run_module, run_path | 14 from runpy import _run_code, _run_module_code, run_module, run_path |
14 # Note: This module can't safely test _run_module_as_main as it | 15 # Note: This module can't safely test _run_module_as_main as it |
15 # runs its tests in the current process, which would mess with the | 16 # runs its tests in the current process, which would mess with the |
16 # real __main__ module (usually test.regrtest) | 17 # real __main__ module (usually test.regrtest) |
17 # See test_cmd_line_script for a test that executes that code path | 18 # See test_cmd_line_script for a test that executes that code path |
18 | 19 |
19 # Set up the test code and expected results | 20 # Set up the test code and expected results |
20 | 21 |
(...skipping 17 matching lines...) Expand all Loading... |
38 "import runpy\n" | 39 "import runpy\n" |
39 "nested = runpy._run_module_code('x=1\\n', mod_name='<run>')\n" | 40 "nested = runpy._run_module_code('x=1\\n', mod_name='<run>')\n" |
40 ) | 41 ) |
41 | 42 |
42 def test_run_code(self): | 43 def test_run_code(self): |
43 saved_argv0 = sys.argv[0] | 44 saved_argv0 = sys.argv[0] |
44 d = _run_code(self.test_source, {}) | 45 d = _run_code(self.test_source, {}) |
45 self.assertEqual(d["result"], self.expected_result) | 46 self.assertEqual(d["result"], self.expected_result) |
46 self.assertIs(d["__name__"], None) | 47 self.assertIs(d["__name__"], None) |
47 self.assertIs(d["__file__"], None) | 48 self.assertIs(d["__file__"], None) |
| 49 self.assertIs(d["__cached__"], None) |
48 self.assertIs(d["__loader__"], None) | 50 self.assertIs(d["__loader__"], None) |
49 self.assertIs(d["__package__"], None) | 51 self.assertIs(d["__package__"], None) |
50 self.assertIs(d["run_argv0"], saved_argv0) | 52 self.assertIs(d["run_argv0"], saved_argv0) |
51 self.assertNotIn("run_name", d) | 53 self.assertNotIn("run_name", d) |
52 self.assertIs(sys.argv[0], saved_argv0) | 54 self.assertIs(sys.argv[0], saved_argv0) |
53 | 55 |
54 def test_run_module_code(self): | 56 def test_run_module_code(self): |
55 initial = object() | 57 initial = object() |
56 name = "<Nonsense>" | 58 name = "<Nonsense>" |
57 file = "Some other nonsense" | 59 file = "Some other nonsense" |
58 loader = "Now you're just being silly" | 60 loader = "Now you're just being silly" |
59 package = '' # Treat as a top level module | 61 package = '' # Treat as a top level module |
60 d1 = dict(initial=initial) | 62 d1 = dict(initial=initial) |
61 saved_argv0 = sys.argv[0] | 63 saved_argv0 = sys.argv[0] |
62 d2 = _run_module_code(self.test_source, | 64 d2 = _run_module_code(self.test_source, |
63 d1, | 65 d1, |
64 name, | 66 name, |
65 file, | 67 file, |
66 loader, | 68 loader, |
67 package) | 69 package) |
68 self.assertNotIn("result", d1) | 70 self.assertNotIn("result", d1) |
69 self.assertIs(d2["initial"], initial) | 71 self.assertIs(d2["initial"], initial) |
70 self.assertEqual(d2["result"], self.expected_result) | 72 self.assertEqual(d2["result"], self.expected_result) |
71 self.assertEqual(d2["nested"]["x"], 1) | 73 self.assertEqual(d2["nested"]["x"], 1) |
72 self.assertIs(d2["__name__"], name) | 74 self.assertIs(d2["__name__"], name) |
73 self.assertTrue(d2["run_name_in_sys_modules"]) | 75 self.assertTrue(d2["run_name_in_sys_modules"]) |
74 self.assertTrue(d2["module_in_sys_modules"]) | 76 self.assertTrue(d2["module_in_sys_modules"]) |
75 self.assertIs(d2["__file__"], file) | 77 self.assertIs(d2["__file__"], file) |
| 78 self.assertIs(d2["__cached__"], None) |
76 self.assertIs(d2["run_argv0"], file) | 79 self.assertIs(d2["run_argv0"], file) |
77 self.assertIs(d2["__loader__"], loader) | 80 self.assertIs(d2["__loader__"], loader) |
78 self.assertIs(d2["__package__"], package) | 81 self.assertIs(d2["__package__"], package) |
79 self.assertIs(sys.argv[0], saved_argv0) | 82 self.assertIs(sys.argv[0], saved_argv0) |
80 self.assertNotIn(name, sys.modules) | 83 self.assertNotIn(name, sys.modules) |
81 | 84 |
82 | 85 |
83 class RunModuleTest(unittest.TestCase): | 86 class RunModuleTest(unittest.TestCase): |
84 """Unit tests for runpy.run_module""" | 87 """Unit tests for runpy.run_module""" |
85 | 88 |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
163 self._make_pkg("x=1\n", depth)) | 166 self._make_pkg("x=1\n", depth)) |
164 forget(mod_name) | 167 forget(mod_name) |
165 try: | 168 try: |
166 if verbose: print("Running from source:", mod_name) | 169 if verbose: print("Running from source:", mod_name) |
167 d1 = run_module(mod_name) # Read from source | 170 d1 = run_module(mod_name) # Read from source |
168 self.assertIn("x", d1) | 171 self.assertIn("x", d1) |
169 self.assertEqual(d1["x"], 1) | 172 self.assertEqual(d1["x"], 1) |
170 del d1 # Ensure __loader__ entry doesn't keep file open | 173 del d1 # Ensure __loader__ entry doesn't keep file open |
171 __import__(mod_name) | 174 __import__(mod_name) |
172 os.remove(mod_fname) | 175 os.remove(mod_fname) |
| 176 make_legacy_pyc(mod_fname) |
173 if verbose: print("Running from compiled:", mod_name) | 177 if verbose: print("Running from compiled:", mod_name) |
174 d2 = run_module(mod_name) # Read from bytecode | 178 d2 = run_module(mod_name) # Read from bytecode |
175 self.assertIn("x", d2) | 179 self.assertIn("x", d2) |
176 self.assertEqual(d2["x"], 1) | 180 self.assertEqual(d2["x"], 1) |
177 del d2 # Ensure __loader__ entry doesn't keep file open | 181 del d2 # Ensure __loader__ entry doesn't keep file open |
178 finally: | 182 finally: |
179 self._del_pkg(pkg_dir, depth, mod_name) | 183 self._del_pkg(pkg_dir, depth, mod_name) |
180 if verbose: print("Module executed successfully") | 184 if verbose: print("Module executed successfully") |
181 | 185 |
182 def _check_package(self, depth): | 186 def _check_package(self, depth): |
183 pkg_dir, mod_fname, mod_name = ( | 187 pkg_dir, mod_fname, mod_name = ( |
184 self._make_pkg("x=1\n", depth, "__main__")) | 188 self._make_pkg("x=1\n", depth, "__main__")) |
185 pkg_name, _, _ = mod_name.rpartition(".") | 189 pkg_name, _, _ = mod_name.rpartition(".") |
186 forget(mod_name) | 190 forget(mod_name) |
187 try: | 191 try: |
188 if verbose: print("Running from source:", pkg_name) | 192 if verbose: print("Running from source:", pkg_name) |
189 d1 = run_module(pkg_name) # Read from source | 193 d1 = run_module(pkg_name) # Read from source |
190 self.assertIn("x", d1) | 194 self.assertIn("x", d1) |
191 self.assertTrue(d1["x"] == 1) | 195 self.assertTrue(d1["x"] == 1) |
192 del d1 # Ensure __loader__ entry doesn't keep file open | 196 del d1 # Ensure __loader__ entry doesn't keep file open |
193 __import__(mod_name) | 197 __import__(mod_name) |
194 os.remove(mod_fname) | 198 os.remove(mod_fname) |
| 199 make_legacy_pyc(mod_fname) |
195 if verbose: print("Running from compiled:", pkg_name) | 200 if verbose: print("Running from compiled:", pkg_name) |
196 d2 = run_module(pkg_name) # Read from bytecode | 201 d2 = run_module(pkg_name) # Read from bytecode |
197 self.assertIn("x", d2) | 202 self.assertIn("x", d2) |
198 self.assertTrue(d2["x"] == 1) | 203 self.assertTrue(d2["x"] == 1) |
199 del d2 # Ensure __loader__ entry doesn't keep file open | 204 del d2 # Ensure __loader__ entry doesn't keep file open |
200 finally: | 205 finally: |
201 self._del_pkg(pkg_dir, depth, pkg_name) | 206 self._del_pkg(pkg_dir, depth, pkg_name) |
202 if verbose: print("Package executed successfully") | 207 if verbose: print("Package executed successfully") |
203 | 208 |
204 def _add_relative_modules(self, base_dir, source, depth): | 209 def _add_relative_modules(self, base_dir, source, depth): |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
239 pkg_name = mod_name.rpartition('.')[0] | 244 pkg_name = mod_name.rpartition('.')[0] |
240 if verbose: print("Running from source:", mod_name) | 245 if verbose: print("Running from source:", mod_name) |
241 d1 = run_module(mod_name, run_name=run_name) # Read from source | 246 d1 = run_module(mod_name, run_name=run_name) # Read from source |
242 self.assertIn("__package__", d1) | 247 self.assertIn("__package__", d1) |
243 self.assertTrue(d1["__package__"] == pkg_name) | 248 self.assertTrue(d1["__package__"] == pkg_name) |
244 self.assertIn("sibling", d1) | 249 self.assertIn("sibling", d1) |
245 self.assertIn("nephew", d1) | 250 self.assertIn("nephew", d1) |
246 del d1 # Ensure __loader__ entry doesn't keep file open | 251 del d1 # Ensure __loader__ entry doesn't keep file open |
247 __import__(mod_name) | 252 __import__(mod_name) |
248 os.remove(mod_fname) | 253 os.remove(mod_fname) |
| 254 make_legacy_pyc(mod_fname) |
249 if verbose: print("Running from compiled:", mod_name) | 255 if verbose: print("Running from compiled:", mod_name) |
250 d2 = run_module(mod_name, run_name=run_name) # Read from bytecode | 256 d2 = run_module(mod_name, run_name=run_name) # Read from bytecode |
251 self.assertIn("__package__", d2) | 257 self.assertIn("__package__", d2) |
252 self.assertTrue(d2["__package__"] == pkg_name) | 258 self.assertTrue(d2["__package__"] == pkg_name) |
253 self.assertIn("sibling", d2) | 259 self.assertIn("sibling", d2) |
254 self.assertIn("nephew", d2) | 260 self.assertIn("nephew", d2) |
255 del d2 # Ensure __loader__ entry doesn't keep file open | 261 del d2 # Ensure __loader__ entry doesn't keep file open |
256 finally: | 262 finally: |
257 self._del_pkg(pkg_dir, depth, mod_name) | 263 self._del_pkg(pkg_dir, depth, mod_name) |
258 if verbose: print("Module executed successfully") | 264 if verbose: print("Module executed successfully") |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
306 def _make_test_script(self, script_dir, script_basename, source=None): | 312 def _make_test_script(self, script_dir, script_basename, source=None): |
307 if source is None: | 313 if source is None: |
308 source = self.test_source | 314 source = self.test_source |
309 return make_script(script_dir, script_basename, source) | 315 return make_script(script_dir, script_basename, source) |
310 | 316 |
311 def _check_script(self, script_name, expected_name, expected_file, | 317 def _check_script(self, script_name, expected_name, expected_file, |
312 expected_argv0, expected_package): | 318 expected_argv0, expected_package): |
313 result = run_path(script_name) | 319 result = run_path(script_name) |
314 self.assertEqual(result["__name__"], expected_name) | 320 self.assertEqual(result["__name__"], expected_name) |
315 self.assertEqual(result["__file__"], expected_file) | 321 self.assertEqual(result["__file__"], expected_file) |
| 322 self.assertEqual(result["__cached__"], None) |
316 self.assertIn("argv0", result) | 323 self.assertIn("argv0", result) |
317 self.assertEqual(result["argv0"], expected_argv0) | 324 self.assertEqual(result["argv0"], expected_argv0) |
318 self.assertEqual(result["__package__"], expected_package) | 325 self.assertEqual(result["__package__"], expected_package) |
319 | 326 |
320 def _check_import_error(self, script_name, msg): | 327 def _check_import_error(self, script_name, msg): |
321 msg = re.escape(msg) | 328 msg = re.escape(msg) |
322 self.assertRaisesRegexp(ImportError, msg, run_path, script_name) | 329 self.assertRaisesRegexp(ImportError, msg, run_path, script_name) |
323 | 330 |
324 def test_basic_script(self): | 331 def test_basic_script(self): |
325 with temp_dir() as script_dir: | 332 with temp_dir() as script_dir: |
326 mod_name = 'script' | 333 mod_name = 'script' |
327 script_name = self._make_test_script(script_dir, mod_name) | 334 script_name = self._make_test_script(script_dir, mod_name) |
328 self._check_script(script_name, "<run_path>", script_name, | 335 self._check_script(script_name, "<run_path>", script_name, |
329 script_name, None) | 336 script_name, None) |
330 | 337 |
331 def test_script_compiled(self): | 338 def test_script_compiled(self): |
332 with temp_dir() as script_dir: | 339 with temp_dir() as script_dir: |
333 mod_name = 'script' | 340 mod_name = 'script' |
334 script_name = self._make_test_script(script_dir, mod_name) | 341 script_name = self._make_test_script(script_dir, mod_name) |
335 compiled_name = compile_script(script_name) | 342 compiled_name = py_compile.compile(script_name, doraise=True) |
336 os.remove(script_name) | 343 os.remove(script_name) |
337 self._check_script(compiled_name, "<run_path>", compiled_name, | 344 self._check_script(compiled_name, "<run_path>", compiled_name, |
338 compiled_name, None) | 345 compiled_name, None) |
339 | 346 |
340 def test_directory(self): | 347 def test_directory(self): |
341 with temp_dir() as script_dir: | 348 with temp_dir() as script_dir: |
342 mod_name = '__main__' | 349 mod_name = '__main__' |
343 script_name = self._make_test_script(script_dir, mod_name) | 350 script_name = self._make_test_script(script_dir, mod_name) |
344 self._check_script(script_dir, "<run_path>", script_name, | 351 self._check_script(script_dir, "<run_path>", script_name, |
345 script_dir, '') | 352 script_dir, '') |
346 | 353 |
347 def test_directory_compiled(self): | 354 def test_directory_compiled(self): |
348 with temp_dir() as script_dir: | 355 with temp_dir() as script_dir: |
349 mod_name = '__main__' | 356 mod_name = '__main__' |
350 script_name = self._make_test_script(script_dir, mod_name) | 357 script_name = self._make_test_script(script_dir, mod_name) |
351 compiled_name = compile_script(script_name) | 358 compiled_name = py_compile.compile(script_name, doraise=True) |
352 os.remove(script_name) | 359 os.remove(script_name) |
353 self._check_script(script_dir, "<run_path>", compiled_name, | 360 legacy_pyc = make_legacy_pyc(script_name) |
| 361 self._check_script(script_dir, "<run_path>", legacy_pyc, |
354 script_dir, '') | 362 script_dir, '') |
355 | 363 |
356 def test_directory_error(self): | 364 def test_directory_error(self): |
357 with temp_dir() as script_dir: | 365 with temp_dir() as script_dir: |
358 mod_name = 'not_main' | 366 mod_name = 'not_main' |
359 script_name = self._make_test_script(script_dir, mod_name) | 367 script_name = self._make_test_script(script_dir, mod_name) |
360 msg = "can't find '__main__' module in %r" % script_dir | 368 msg = "can't find '__main__' module in %r" % script_dir |
361 self._check_import_error(script_dir, msg) | 369 self._check_import_error(script_dir, msg) |
362 | 370 |
363 def test_zipfile(self): | 371 def test_zipfile(self): |
364 with temp_dir() as script_dir: | 372 with temp_dir() as script_dir: |
365 mod_name = '__main__' | 373 mod_name = '__main__' |
366 script_name = self._make_test_script(script_dir, mod_name) | 374 script_name = self._make_test_script(script_dir, mod_name) |
367 zip_name, fname = make_zip_script(script_dir, 'test_zip', script_nam
e) | 375 zip_name, fname = make_zip_script(script_dir, 'test_zip', script_nam
e) |
368 self._check_script(zip_name, "<run_path>", fname, zip_name, '') | 376 self._check_script(zip_name, "<run_path>", fname, zip_name, '') |
369 | 377 |
370 def test_zipfile_compiled(self): | 378 def test_zipfile_compiled(self): |
371 with temp_dir() as script_dir: | 379 with temp_dir() as script_dir: |
372 mod_name = '__main__' | 380 mod_name = '__main__' |
373 script_name = self._make_test_script(script_dir, mod_name) | 381 script_name = self._make_test_script(script_dir, mod_name) |
374 compiled_name = compile_script(script_name) | 382 compiled_name = py_compile.compile(script_name, doraise=True) |
375 zip_name, fname = make_zip_script(script_dir, 'test_zip', compiled_n
ame) | 383 zip_name, fname = make_zip_script(script_dir, 'test_zip', |
| 384 compiled_name) |
376 self._check_script(zip_name, "<run_path>", fname, zip_name, '') | 385 self._check_script(zip_name, "<run_path>", fname, zip_name, '') |
377 | 386 |
378 def test_zipfile_error(self): | 387 def test_zipfile_error(self): |
379 with temp_dir() as script_dir: | 388 with temp_dir() as script_dir: |
380 mod_name = 'not_main' | 389 mod_name = 'not_main' |
381 script_name = self._make_test_script(script_dir, mod_name) | 390 script_name = self._make_test_script(script_dir, mod_name) |
382 zip_name, fname = make_zip_script(script_dir, 'test_zip', script_nam
e) | 391 zip_name, fname = make_zip_script(script_dir, 'test_zip', script_nam
e) |
383 msg = "can't find '__main__' module in %r" % zip_name | 392 msg = "can't find '__main__' module in %r" % zip_name |
384 self._check_import_error(zip_name, msg) | 393 self._check_import_error(zip_name, msg) |
385 | 394 |
386 def test_main_recursion_error(self): | 395 def test_main_recursion_error(self): |
387 with temp_dir() as script_dir, temp_dir() as dummy_dir: | 396 with temp_dir() as script_dir, temp_dir() as dummy_dir: |
388 mod_name = '__main__' | 397 mod_name = '__main__' |
389 source = ("import runpy\n" | 398 source = ("import runpy\n" |
390 "runpy.run_path(%r)\n") % dummy_dir | 399 "runpy.run_path(%r)\n") % dummy_dir |
391 script_name = self._make_test_script(script_dir, mod_name, source) | 400 script_name = self._make_test_script(script_dir, mod_name, source) |
392 zip_name, fname = make_zip_script(script_dir, 'test_zip', script_nam
e) | 401 zip_name, fname = make_zip_script(script_dir, 'test_zip', script_nam
e) |
393 msg = "recursion depth exceeded" | 402 msg = "recursion depth exceeded" |
394 self.assertRaisesRegexp(RuntimeError, msg, run_path, zip_name) | 403 self.assertRaisesRegexp(RuntimeError, msg, run_path, zip_name) |
395 | 404 |
396 | 405 |
397 | 406 |
398 def test_main(): | 407 def test_main(): |
399 run_unittest(RunModuleCodeTest, RunModuleTest, RunPathTest) | 408 run_unittest(RunModuleCodeTest, RunModuleTest, RunPathTest) |
400 | 409 |
401 if __name__ == "__main__": | 410 if __name__ == "__main__": |
402 test_main() | 411 test_main() |
OLD | NEW |