Home | History | Annotate | Download | only in test
      1 # Test the runpy module
      2 import unittest
      3 import os
      4 import os.path
      5 import sys
      6 import re
      7 import tempfile
      8 from test.test_support import verbose, run_unittest, forget
      9 from test.script_helper import (temp_dir, make_script, compile_script,
     10                                 make_pkg, make_zip_script, make_zip_pkg)
     11 
     12 
     13 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 # runs its tests in the current process, which would mess with the
     16 # real __main__ module (usually test.regrtest)
     17 # See test_cmd_line_script for a test that executes that code path
     18 
     19 # Set up the test code and expected results
     20 
     21 class RunModuleCodeTest(unittest.TestCase):
     22     """Unit tests for runpy._run_code and runpy._run_module_code"""
     23 
     24     expected_result = ["Top level assignment", "Lower level reference"]
     25     test_source = (
     26         "# Check basic code execution\n"
     27         "result = ['Top level assignment']\n"
     28         "def f():\n"
     29         "    result.append('Lower level reference')\n"
     30         "f()\n"
     31         "# Check the sys module\n"
     32         "import sys\n"
     33         "run_argv0 = sys.argv[0]\n"
     34         "run_name_in_sys_modules = __name__ in sys.modules\n"
     35         "if run_name_in_sys_modules:\n"
     36         "   module_in_sys_modules = globals() is sys.modules[__name__].__dict__\n"
     37         "# Check nested operation\n"
     38         "import runpy\n"
     39         "nested = runpy._run_module_code('x=1\\n', mod_name='<run>')\n"
     40     )
     41 
     42     def test_run_code(self):
     43         saved_argv0 = sys.argv[0]
     44         d = _run_code(self.test_source, {})
     45         self.assertEqual(d["result"], self.expected_result)
     46         self.assertIs(d["__name__"], None)
     47         self.assertIs(d["__file__"], None)
     48         self.assertIs(d["__loader__"], None)
     49         self.assertIs(d["__package__"], None)
     50         self.assertIs(d["run_argv0"], saved_argv0)
     51         self.assertNotIn("run_name", d)
     52         self.assertIs(sys.argv[0], saved_argv0)
     53 
     54     def test_run_module_code(self):
     55         initial = object()
     56         name = "<Nonsense>"
     57         file = "Some other nonsense"
     58         loader = "Now you're just being silly"
     59         package = '' # Treat as a top level module
     60         d1 = dict(initial=initial)
     61         saved_argv0 = sys.argv[0]
     62         d2 = _run_module_code(self.test_source,
     63                               d1,
     64                               name,
     65                               file,
     66                               loader,
     67                               package)
     68         self.assertNotIn("result", d1)
     69         self.assertIs(d2["initial"], initial)
     70         self.assertEqual(d2["result"], self.expected_result)
     71         self.assertEqual(d2["nested"]["x"], 1)
     72         self.assertIs(d2["__name__"], name)
     73         self.assertTrue(d2["run_name_in_sys_modules"])
     74         self.assertTrue(d2["module_in_sys_modules"])
     75         self.assertIs(d2["__file__"], file)
     76         self.assertIs(d2["run_argv0"], file)
     77         self.assertIs(d2["__loader__"], loader)
     78         self.assertIs(d2["__package__"], package)
     79         self.assertIs(sys.argv[0], saved_argv0)
     80         self.assertNotIn(name, sys.modules)
     81 
     82 
     83 class RunModuleTest(unittest.TestCase):
     84     """Unit tests for runpy.run_module"""
     85 
     86     def expect_import_error(self, mod_name):
     87         try:
     88             run_module(mod_name)
     89         except ImportError:
     90             pass
     91         else:
     92             self.fail("Expected import error for " + mod_name)
     93 
     94     def test_invalid_names(self):
     95         # Builtin module
     96         self.expect_import_error("sys")
     97         # Non-existent modules
     98         self.expect_import_error("sys.imp.eric")
     99         self.expect_import_error("os.path.half")
    100         self.expect_import_error("a.bee")
    101         self.expect_import_error(".howard")
    102         self.expect_import_error("..eaten")
    103         # Package without __main__.py
    104         self.expect_import_error("multiprocessing")
    105 
    106     def test_library_module(self):
    107         run_module("runpy")
    108 
    109     def _add_pkg_dir(self, pkg_dir):
    110         os.mkdir(pkg_dir)
    111         pkg_fname = os.path.join(pkg_dir, "__init__"+os.extsep+"py")
    112         pkg_file = open(pkg_fname, "w")
    113         pkg_file.close()
    114         return pkg_fname
    115 
    116     def _make_pkg(self, source, depth, mod_base="runpy_test"):
    117         pkg_name = "__runpy_pkg__"
    118         test_fname = mod_base+os.extsep+"py"
    119         pkg_dir = sub_dir = tempfile.mkdtemp()
    120         if verbose: print "  Package tree in:", sub_dir
    121         sys.path.insert(0, pkg_dir)
    122         if verbose: print "  Updated sys.path:", sys.path[0]
    123         for i in range(depth):
    124             sub_dir = os.path.join(sub_dir, pkg_name)
    125             pkg_fname = self._add_pkg_dir(sub_dir)
    126             if verbose: print "  Next level in:", sub_dir
    127             if verbose: print "  Created:", pkg_fname
    128         mod_fname = os.path.join(sub_dir, test_fname)
    129         mod_file = open(mod_fname, "w")
    130         mod_file.write(source)
    131         mod_file.close()
    132         if verbose: print "  Created:", mod_fname
    133         mod_name = (pkg_name+".")*depth + mod_base
    134         return pkg_dir, mod_fname, mod_name
    135 
    136     def _del_pkg(self, top, depth, mod_name):
    137         for entry in list(sys.modules):
    138             if entry.startswith("__runpy_pkg__"):
    139                 del sys.modules[entry]
    140         if verbose: print "  Removed sys.modules entries"
    141         del sys.path[0]
    142         if verbose: print "  Removed sys.path entry"
    143         for root, dirs, files in os.walk(top, topdown=False):
    144             for name in files:
    145                 try:
    146                     os.remove(os.path.join(root, name))
    147                 except OSError, ex:
    148                     if verbose: print ex # Persist with cleaning up
    149             for name in dirs:
    150                 fullname = os.path.join(root, name)
    151                 try:
    152                     os.rmdir(fullname)
    153                 except OSError, ex:
    154                     if verbose: print ex # Persist with cleaning up
    155         try:
    156             os.rmdir(top)
    157             if verbose: print "  Removed package tree"
    158         except OSError, ex:
    159             if verbose: print ex # Persist with cleaning up
    160 
    161     def _check_module(self, depth):
    162         pkg_dir, mod_fname, mod_name = (
    163                self._make_pkg("x=1\n", depth))
    164         forget(mod_name)
    165         try:
    166             if verbose: print "Running from source:", mod_name
    167             d1 = run_module(mod_name) # Read from source
    168             self.assertIn("x", d1)
    169             self.assertTrue(d1["x"] == 1)
    170             del d1 # Ensure __loader__ entry doesn't keep file open
    171             __import__(mod_name)
    172             os.remove(mod_fname)
    173             if not sys.dont_write_bytecode:
    174                 if verbose: print "Running from compiled:", mod_name
    175                 d2 = run_module(mod_name) # Read from bytecode
    176                 self.assertIn("x", d2)
    177                 self.assertTrue(d2["x"] == 1)
    178                 del d2 # Ensure __loader__ entry doesn't keep file open
    179         finally:
    180             self._del_pkg(pkg_dir, depth, mod_name)
    181         if verbose: print "Module executed successfully"
    182 
    183     def _check_package(self, depth):
    184         pkg_dir, mod_fname, mod_name = (
    185                self._make_pkg("x=1\n", depth, "__main__"))
    186         pkg_name, _, _ = mod_name.rpartition(".")
    187         forget(mod_name)
    188         try:
    189             if verbose: print "Running from source:", pkg_name
    190             d1 = run_module(pkg_name) # Read from source
    191             self.assertIn("x", d1)
    192             self.assertTrue(d1["x"] == 1)
    193             del d1 # Ensure __loader__ entry doesn't keep file open
    194             __import__(mod_name)
    195             os.remove(mod_fname)
    196             if not sys.dont_write_bytecode:
    197                 if verbose: print "Running from compiled:", pkg_name
    198                 d2 = run_module(pkg_name) # Read from bytecode
    199                 self.assertIn("x", d2)
    200                 self.assertTrue(d2["x"] == 1)
    201                 del d2 # Ensure __loader__ entry doesn't keep file open
    202         finally:
    203             self._del_pkg(pkg_dir, depth, pkg_name)
    204         if verbose: print "Package executed successfully"
    205 
    206     def _add_relative_modules(self, base_dir, source, depth):
    207         if depth <= 1:
    208             raise ValueError("Relative module test needs depth > 1")
    209         pkg_name = "__runpy_pkg__"
    210         module_dir = base_dir
    211         for i in range(depth):
    212             parent_dir = module_dir
    213             module_dir = os.path.join(module_dir, pkg_name)
    214         # Add sibling module
    215         sibling_fname = os.path.join(module_dir, "sibling"+os.extsep+"py")
    216         sibling_file = open(sibling_fname, "w")
    217         sibling_file.close()
    218         if verbose: print "  Added sibling module:", sibling_fname
    219         # Add nephew module
    220         uncle_dir = os.path.join(parent_dir, "uncle")
    221         self._add_pkg_dir(uncle_dir)
    222         if verbose: print "  Added uncle package:", uncle_dir
    223         cousin_dir = os.path.join(uncle_dir, "cousin")
    224         self._add_pkg_dir(cousin_dir)
    225         if verbose: print "  Added cousin package:", cousin_dir
    226         nephew_fname = os.path.join(cousin_dir, "nephew"+os.extsep+"py")
    227         nephew_file = open(nephew_fname, "w")
    228         nephew_file.close()
    229         if verbose: print "  Added nephew module:", nephew_fname
    230 
    231     def _check_relative_imports(self, depth, run_name=None):
    232         contents = r"""\
    233 from __future__ import absolute_import
    234 from . import sibling
    235 from ..uncle.cousin import nephew
    236 """
    237         pkg_dir, mod_fname, mod_name = (
    238                self._make_pkg(contents, depth))
    239         try:
    240             self._add_relative_modules(pkg_dir, contents, depth)
    241             pkg_name = mod_name.rpartition('.')[0]
    242             if verbose: print "Running from source:", mod_name
    243             d1 = run_module(mod_name, run_name=run_name) # Read from source
    244             self.assertIn("__package__", d1)
    245             self.assertTrue(d1["__package__"] == pkg_name)
    246             self.assertIn("sibling", d1)
    247             self.assertIn("nephew", d1)
    248             del d1 # Ensure __loader__ entry doesn't keep file open
    249             __import__(mod_name)
    250             os.remove(mod_fname)
    251             if not sys.dont_write_bytecode:
    252                 if verbose: print "Running from compiled:", mod_name
    253                 d2 = run_module(mod_name, run_name=run_name) # Read from bytecode
    254                 self.assertIn("__package__", d2)
    255                 self.assertTrue(d2["__package__"] == pkg_name)
    256                 self.assertIn("sibling", d2)
    257                 self.assertIn("nephew", d2)
    258                 del d2 # Ensure __loader__ entry doesn't keep file open
    259         finally:
    260             self._del_pkg(pkg_dir, depth, mod_name)
    261         if verbose: print "Module executed successfully"
    262 
    263     def test_run_module(self):
    264         for depth in range(4):
    265             if verbose: print "Testing package depth:", depth
    266             self._check_module(depth)
    267 
    268     def test_run_package(self):
    269         for depth in range(1, 4):
    270             if verbose: print "Testing package depth:", depth
    271             self._check_package(depth)
    272 
    273     def test_explicit_relative_import(self):
    274         for depth in range(2, 5):
    275             if verbose: print "Testing relative imports at depth:", depth
    276             self._check_relative_imports(depth)
    277 
    278     def test_main_relative_import(self):
    279         for depth in range(2, 5):
    280             if verbose: print "Testing main relative imports at depth:", depth
    281             self._check_relative_imports(depth, "__main__")
    282 
    283 
    284 class RunPathTest(unittest.TestCase):
    285     """Unit tests for runpy.run_path"""
    286     # Based on corresponding tests in test_cmd_line_script
    287 
    288     test_source = """\
    289 # Script may be run with optimisation enabled, so don't rely on assert
    290 # statements being executed
    291 def assertEqual(lhs, rhs):
    292     if lhs != rhs:
    293         raise AssertionError('%r != %r' % (lhs, rhs))
    294 def assertIs(lhs, rhs):
    295     if lhs is not rhs:
    296         raise AssertionError('%r is not %r' % (lhs, rhs))
    297 # Check basic code execution
    298 result = ['Top level assignment']
    299 def f():
    300     result.append('Lower level reference')
    301 f()
    302 assertEqual(result, ['Top level assignment', 'Lower level reference'])
    303 # Check the sys module
    304 import sys
    305 assertIs(globals(), sys.modules[__name__].__dict__)
    306 argv0 = sys.argv[0]
    307 """
    308 
    309     def _make_test_script(self, script_dir, script_basename, source=None):
    310         if source is None:
    311             source = self.test_source
    312         return make_script(script_dir, script_basename, source)
    313 
    314     def _check_script(self, script_name, expected_name, expected_file,
    315                             expected_argv0, expected_package):
    316         result = run_path(script_name)
    317         self.assertEqual(result["__name__"], expected_name)
    318         self.assertEqual(result["__file__"], expected_file)
    319         self.assertIn("argv0", result)
    320         self.assertEqual(result["argv0"], expected_argv0)
    321         self.assertEqual(result["__package__"], expected_package)
    322 
    323     def _check_import_error(self, script_name, msg):
    324         msg = re.escape(msg)
    325         self.assertRaisesRegexp(ImportError, msg, run_path, script_name)
    326 
    327     def test_basic_script(self):
    328         with temp_dir() as script_dir:
    329             mod_name = 'script'
    330             script_name = self._make_test_script(script_dir, mod_name)
    331             self._check_script(script_name, "<run_path>", script_name,
    332                                script_name, None)
    333 
    334     def test_script_compiled(self):
    335         with temp_dir() as script_dir:
    336             mod_name = 'script'
    337             script_name = self._make_test_script(script_dir, mod_name)
    338             compiled_name = compile_script(script_name)
    339             os.remove(script_name)
    340             self._check_script(compiled_name, "<run_path>", compiled_name,
    341                                compiled_name, None)
    342 
    343     def test_directory(self):
    344         with temp_dir() as script_dir:
    345             mod_name = '__main__'
    346             script_name = self._make_test_script(script_dir, mod_name)
    347             self._check_script(script_dir, "<run_path>", script_name,
    348                                script_dir, '')
    349 
    350     def test_directory_compiled(self):
    351         with temp_dir() as script_dir:
    352             mod_name = '__main__'
    353             script_name = self._make_test_script(script_dir, mod_name)
    354             compiled_name = compile_script(script_name)
    355             os.remove(script_name)
    356             self._check_script(script_dir, "<run_path>", compiled_name,
    357                                script_dir, '')
    358 
    359     def test_directory_error(self):
    360         with temp_dir() as script_dir:
    361             mod_name = 'not_main'
    362             script_name = self._make_test_script(script_dir, mod_name)
    363             msg = "can't find '__main__' module in %r" % script_dir
    364             self._check_import_error(script_dir, msg)
    365 
    366     def test_zipfile(self):
    367         with temp_dir() as script_dir:
    368             mod_name = '__main__'
    369             script_name = self._make_test_script(script_dir, mod_name)
    370             zip_name, fname = make_zip_script(script_dir, 'test_zip', script_name)
    371             self._check_script(zip_name, "<run_path>", fname, zip_name, '')
    372 
    373     def test_zipfile_compiled(self):
    374         with temp_dir() as script_dir:
    375             mod_name = '__main__'
    376             script_name = self._make_test_script(script_dir, mod_name)
    377             compiled_name = compile_script(script_name)
    378             zip_name, fname = make_zip_script(script_dir, 'test_zip', compiled_name)
    379             self._check_script(zip_name, "<run_path>", fname, zip_name, '')
    380 
    381     def test_zipfile_error(self):
    382         with temp_dir() as script_dir:
    383             mod_name = 'not_main'
    384             script_name = self._make_test_script(script_dir, mod_name)
    385             zip_name, fname = make_zip_script(script_dir, 'test_zip', script_name)
    386             msg = "can't find '__main__' module in %r" % zip_name
    387             self._check_import_error(zip_name, msg)
    388 
    389     def test_main_recursion_error(self):
    390         with temp_dir() as script_dir, temp_dir() as dummy_dir:
    391             mod_name = '__main__'
    392             source = ("import runpy\n"
    393                       "runpy.run_path(%r)\n") % dummy_dir
    394             script_name = self._make_test_script(script_dir, mod_name, source)
    395             zip_name, fname = make_zip_script(script_dir, 'test_zip', script_name)
    396             msg = "recursion depth exceeded"
    397             self.assertRaisesRegexp(RuntimeError, msg, run_path, zip_name)
    398 
    399 
    400 
    401 def test_main():
    402     run_unittest(RunModuleCodeTest, RunModuleTest, RunPathTest)
    403 
    404 if __name__ == "__main__":
    405     test_main()
    406