225 lines
8.2 KiB
Python
225 lines
8.2 KiB
Python
# Tests command line execution of scripts
|
|
|
|
import unittest
|
|
import os
|
|
import os.path
|
|
import sys
|
|
import test.test_support
|
|
import tempfile
|
|
import subprocess
|
|
import py_compile
|
|
import contextlib
|
|
import shutil
|
|
import zipfile
|
|
|
|
verbose = test.test_support.verbose
|
|
|
|
# XXX ncoghlan: Should we consider moving these to test_support?
|
|
from 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
|
|
|
|
@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.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.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.assert_(printed_file in data)
|
|
self.assert_(printed_package in data)
|
|
self.assert_(printed_argv0 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_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_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_main():
|
|
test.test_support.run_unittest(CmdLineTest)
|
|
test.test_support.reap_children()
|
|
|
|
if __name__ == '__main__':
|
|
test_main()
|