| # Tests command line execution of scripts |
| |
| import unittest |
| import os |
| import os.path |
| import sys |
| import test.support |
| import tempfile |
| import subprocess |
| import py_compile |
| import contextlib |
| import shutil |
| import zipfile |
| |
| verbose = test.support.verbose |
| |
| # XXX ncoghlan: Should we consider moving these to support? |
| from test.test_cmd_line import _spawn_python, _kill_python |
| |
| def _run_python(*args): |
| if __debug__: |
| p = _spawn_python(*args) |
| else: |
| p = _spawn_python('-O', *args) |
| stdout_data = _kill_python(p) |
| return p.wait(), stdout_data.decode() |
| |
| @contextlib.contextmanager |
| def temp_dir(): |
| dirname = tempfile.mkdtemp() |
| dirname = os.path.realpath(dirname) |
| try: |
| yield dirname |
| finally: |
| shutil.rmtree(dirname) |
| |
| test_source = """\ |
| # Script may be run with optimisation enabled, so don't rely on assert |
| # statements being executed |
| def assertEqual(lhs, rhs): |
| if lhs != rhs: |
| raise AssertionError('%r != %r' % (lhs, rhs)) |
| def assertIdentical(lhs, rhs): |
| if lhs is not rhs: |
| raise AssertionError('%r is not %r' % (lhs, rhs)) |
| # Check basic code execution |
| result = ['Top level assignment'] |
| def f(): |
| result.append('Lower level reference') |
| f() |
| assertEqual(result, ['Top level assignment', 'Lower level reference']) |
| # Check population of magic variables |
| assertEqual(__name__, '__main__') |
| print('__file__==%r' % __file__) |
| print('__package__==%r' % __package__) |
| # Check the sys module |
| import sys |
| assertIdentical(globals(), sys.modules[__name__].__dict__) |
| print('sys.argv[0]==%r' % sys.argv[0]) |
| """ |
| |
| def _make_test_script(script_dir, script_basename, source=test_source): |
| script_filename = script_basename+os.path.extsep+'py' |
| script_name = os.path.join(script_dir, script_filename) |
| script_file = open(script_name, 'w') |
| script_file.write(source) |
| script_file.close() |
| return script_name |
| |
| def _compile_test_script(script_name): |
| py_compile.compile(script_name, doraise=True) |
| if __debug__: |
| compiled_name = script_name + 'c' |
| else: |
| compiled_name = script_name + 'o' |
| return compiled_name |
| |
| def _make_test_zip(zip_dir, zip_basename, script_name, name_in_zip=None): |
| zip_filename = zip_basename+os.path.extsep+"zip" |
| zip_name = os.path.join(zip_dir, zip_filename) |
| zip_file = zipfile.ZipFile(zip_name, 'w') |
| if name_in_zip is None: |
| name_in_zip = os.path.basename(script_name) |
| zip_file.write(script_name, name_in_zip) |
| zip_file.close() |
| #if verbose: |
| # zip_file = zipfile.ZipFile(zip_name, 'r') |
| # print("Contents of %r:" % zip_name) |
| # zip_file.printdir() |
| # zip_file.close() |
| return zip_name, os.path.join(zip_name, name_in_zip) |
| |
| def _make_test_pkg(pkg_dir): |
| os.mkdir(pkg_dir) |
| _make_test_script(pkg_dir, '__init__', '') |
| |
| def _make_test_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename, |
| source=test_source, depth=1): |
| init_name = _make_test_script(zip_dir, '__init__', '') |
| init_basename = os.path.basename(init_name) |
| script_name = _make_test_script(zip_dir, script_basename, source) |
| pkg_names = [os.sep.join([pkg_name]*i) for i in range(1, depth+1)] |
| script_name_in_zip = os.path.join(pkg_names[-1], os.path.basename(script_name)) |
| zip_filename = zip_basename+os.extsep+'zip' |
| zip_name = os.path.join(zip_dir, zip_filename) |
| zip_file = zipfile.ZipFile(zip_name, 'w') |
| for name in pkg_names: |
| init_name_in_zip = os.path.join(name, init_basename) |
| zip_file.write(init_name, init_name_in_zip) |
| zip_file.write(script_name, script_name_in_zip) |
| zip_file.close() |
| os.unlink(init_name) |
| os.unlink(script_name) |
| #if verbose: |
| # zip_file = zipfile.ZipFile(zip_name, 'r') |
| # print('Contents of %r:' % zip_name) |
| # zip_file.printdir() |
| # zip_file.close() |
| return zip_name, os.path.join(zip_name, script_name_in_zip) |
| |
| # There's no easy way to pass the script directory in to get |
| # -m to work (avoiding that is the whole point of making |
| # directories and zipfiles executable!) |
| # So we fake it for testing purposes with a custom launch script |
| launch_source = """\ |
| import sys, os.path, runpy |
| sys.path.insert(0, %s) |
| runpy._run_module_as_main(%r) |
| """ |
| |
| def _make_launch_script(script_dir, script_basename, module_name, path=None): |
| if path is None: |
| path = "os.path.dirname(__file__)" |
| else: |
| path = repr(path) |
| source = launch_source % (path, module_name) |
| return _make_test_script(script_dir, script_basename, source) |
| |
| class CmdLineTest(unittest.TestCase): |
| def _check_script(self, script_name, expected_file, |
| expected_argv0, expected_package, |
| *cmd_line_switches): |
| run_args = cmd_line_switches + (script_name,) |
| exit_code, data = _run_python(*run_args) |
| if verbose: |
| print("Output from test script %r:" % script_name) |
| print(data) |
| self.assertEqual(exit_code, 0) |
| printed_file = '__file__==%r' % expected_file |
| printed_argv0 = 'sys.argv[0]==%r' % expected_argv0 |
| printed_package = '__package__==%r' % expected_package |
| if verbose: |
| print('Expected output:') |
| print(printed_file) |
| print(printed_package) |
| print(printed_argv0) |
| self.assertTrue(printed_file in data) |
| self.assertTrue(printed_package in data) |
| self.assertTrue(printed_argv0 in data) |
| |
| def _check_import_error(self, script_name, expected_msg, |
| *cmd_line_switches): |
| run_args = cmd_line_switches + (script_name,) |
| exit_code, data = _run_python(*run_args) |
| if verbose: |
| print('Output from test script %r:' % script_name) |
| print(data) |
| print('Expected output: %r' % expected_msg) |
| self.assertTrue(expected_msg in data) |
| |
| def test_basic_script(self): |
| with temp_dir() as script_dir: |
| script_name = _make_test_script(script_dir, 'script') |
| self._check_script(script_name, script_name, script_name, None) |
| |
| def test_script_compiled(self): |
| with temp_dir() as script_dir: |
| script_name = _make_test_script(script_dir, 'script') |
| compiled_name = _compile_test_script(script_name) |
| os.remove(script_name) |
| self._check_script(compiled_name, compiled_name, compiled_name, None) |
| |
| def test_directory(self): |
| with temp_dir() as script_dir: |
| script_name = _make_test_script(script_dir, '__main__') |
| self._check_script(script_dir, script_name, script_dir, '') |
| |
| def test_directory_compiled(self): |
| with temp_dir() as script_dir: |
| script_name = _make_test_script(script_dir, '__main__') |
| compiled_name = _compile_test_script(script_name) |
| os.remove(script_name) |
| self._check_script(script_dir, compiled_name, script_dir, '') |
| |
| def test_directory_error(self): |
| with temp_dir() as script_dir: |
| msg = "can't find '__main__.py' in %r" % script_dir |
| self._check_import_error(script_dir, msg) |
| |
| def test_zipfile(self): |
| with temp_dir() as script_dir: |
| script_name = _make_test_script(script_dir, '__main__') |
| zip_name, run_name = _make_test_zip(script_dir, 'test_zip', script_name) |
| self._check_script(zip_name, run_name, zip_name, '') |
| |
| def test_zipfile_compiled(self): |
| with temp_dir() as script_dir: |
| script_name = _make_test_script(script_dir, '__main__') |
| compiled_name = _compile_test_script(script_name) |
| zip_name, run_name = _make_test_zip(script_dir, 'test_zip', compiled_name) |
| self._check_script(zip_name, run_name, zip_name, '') |
| |
| def test_zipfile_error(self): |
| with temp_dir() as script_dir: |
| script_name = _make_test_script(script_dir, 'not_main') |
| zip_name, run_name = _make_test_zip(script_dir, 'test_zip', script_name) |
| msg = "can't find '__main__.py' in %r" % zip_name |
| self._check_import_error(zip_name, msg) |
| |
| def test_module_in_package(self): |
| with temp_dir() as script_dir: |
| pkg_dir = os.path.join(script_dir, 'test_pkg') |
| _make_test_pkg(pkg_dir) |
| script_name = _make_test_script(pkg_dir, 'script') |
| launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg.script') |
| self._check_script(launch_name, script_name, script_name, 'test_pkg') |
| |
| def test_module_in_package_in_zipfile(self): |
| with temp_dir() as script_dir: |
| zip_name, run_name = _make_test_zip_pkg(script_dir, 'test_zip', 'test_pkg', 'script') |
| launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg.script', zip_name) |
| self._check_script(launch_name, run_name, run_name, 'test_pkg') |
| |
| def test_module_in_subpackage_in_zipfile(self): |
| with temp_dir() as script_dir: |
| zip_name, run_name = _make_test_zip_pkg(script_dir, 'test_zip', 'test_pkg', 'script', depth=2) |
| launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg.test_pkg.script', zip_name) |
| self._check_script(launch_name, run_name, run_name, 'test_pkg.test_pkg') |
| |
| def test_package(self): |
| with temp_dir() as script_dir: |
| pkg_dir = os.path.join(script_dir, 'test_pkg') |
| _make_test_pkg(pkg_dir) |
| script_name = _make_test_script(pkg_dir, '__main__') |
| launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg') |
| self._check_script(launch_name, script_name, |
| script_name, 'test_pkg') |
| |
| def test_package_compiled(self): |
| with temp_dir() as script_dir: |
| pkg_dir = os.path.join(script_dir, 'test_pkg') |
| _make_test_pkg(pkg_dir) |
| script_name = _make_test_script(pkg_dir, '__main__') |
| compiled_name = _compile_test_script(script_name) |
| os.remove(script_name) |
| launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg') |
| self._check_script(launch_name, compiled_name, |
| compiled_name, 'test_pkg') |
| |
| def test_package_error(self): |
| with temp_dir() as script_dir: |
| pkg_dir = os.path.join(script_dir, 'test_pkg') |
| _make_test_pkg(pkg_dir) |
| msg = ("'test_pkg' is a package and cannot " |
| "be directly executed") |
| launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg') |
| self._check_import_error(launch_name, msg) |
| |
| def test_package_recursion(self): |
| with temp_dir() as script_dir: |
| pkg_dir = os.path.join(script_dir, 'test_pkg') |
| _make_test_pkg(pkg_dir) |
| main_dir = os.path.join(pkg_dir, '__main__') |
| _make_test_pkg(main_dir) |
| msg = ("Cannot use package as __main__ module; " |
| "'test_pkg' is a package and cannot " |
| "be directly executed") |
| launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg') |
| self._check_import_error(launch_name, msg) |
| |
| |
| def test_main(): |
| test.support.run_unittest(CmdLineTest) |
| test.support.reap_children() |
| |
| if __name__ == '__main__': |
| test_main() |