script_helper.py

# Common utility functions used by various script execution tests
# e.g. test_cmd_line, test_cmd_line_script and test_runpy

importcollections
importimportlib
importsys
importos
importos.path
importsubprocess
importpy_compile
importzipfile

fromimportlib.utilimportsource_from_cache
fromtest.supportimportmake_legacy_pyc, strip_python_stderr


# Cached result of the expensive test performed in the function below.
__cached_interp_requires_environment=None

definterpreter_requires_environment():
"""
 Returns True if our sys.executable interpreter requires environment
 variables in order to be able to run at all.

 This is designed to be used with @unittest.skipIf() to annotate tests
 that need to use an assert_python*() function to launch an isolated
 mode (-I) or no environment mode (-E) sub-interpreter process.

 A normal build & test does not run into this situation but it can happen
 when trying to run the standard library test suite from an interpreter that
 doesn't have an obvious home with Python's current home finding logic.

 Setting PYTHONHOME is one way to get most of the testsuite to run in that
 situation. PYTHONPATH or PYTHONUSERSITE are other common environment
 variables that might impact whether or not the interpreter can start.
 """
global__cached_interp_requires_environment
if__cached_interp_requires_environmentisNone:
# If PYTHONHOME is set, assume that we need it
if'PYTHONHOME'inos.environ:
__cached_interp_requires_environment=True
returnTrue

# Try running an interpreter with -E to see if it works or not.
try:
subprocess.check_call([sys.executable, '-E',
'-c', 'import sys; sys.exit(0)'])
exceptsubprocess.CalledProcessError:
__cached_interp_requires_environment=True
else:
__cached_interp_requires_environment=False

return__cached_interp_requires_environment


class_PythonRunResult(collections.namedtuple("_PythonRunResult",
 ("rc", "out", "err"))):
"""Helper for reporting Python subprocess run results"""
deffail(self, cmd_line):
"""Provide helpful details about failed subcommand runs"""
# Limit to 80 lines to ASCII characters
maxlen=80*100
out, err=self.out, self.err
iflen(out) >maxlen:
out=b'(... truncated stdout ...)'+out[-maxlen:]
iflen(err) >maxlen:
err=b'(... truncated stderr ...)'+err[-maxlen:]
out=out.decode('ascii', 'replace').rstrip()
err=err.decode('ascii', 'replace').rstrip()
raiseAssertionError("Process return code is %d\n"
"command line: %r\n"
"\n"
"stdout:\n"
"---\n"
"%s\n"
"---\n"
"\n"
"stderr:\n"
"---\n"
"%s\n"
"---"
% (self.rc, cmd_line,
out,
err))


# Executing the interpreter in a subprocess
defrun_python_until_end(*args, **env_vars):
env_required=interpreter_requires_environment()
cwd=env_vars.pop('__cwd', None)
if'__isolated'inenv_vars:
isolated=env_vars.pop('__isolated')
else:
isolated=notenv_varsandnotenv_required
cmd_line= [sys.executable, '-X', 'faulthandler']
ifisolated:
# isolated mode: ignore Python environment variables, ignore user
# site-packages, and don't add the current directory to sys.path
cmd_line.append('-I')
elifnotenv_varsandnotenv_required:
# ignore Python environment variables
cmd_line.append('-E')

# But a special flag that can be set to override -- in this case, the
# caller is responsible to pass the full environment.
ifenv_vars.pop('__cleanenv', None):
env= {}
ifsys.platform=='win32':
# Windows requires at least the SYSTEMROOT environment variable to
# start Python.
env['SYSTEMROOT'] =os.environ['SYSTEMROOT']

# Other interesting environment variables, not copied currently:
# COMSPEC, HOME, PATH, TEMP, TMPDIR, TMP.
else:
# Need to preserve the original environment, for in-place testing of
# shared library builds.
env=os.environ.copy()

# set TERM='' unless the TERM environment variable is passed explicitly
# see issues #11390 and #18300
if'TERM'notinenv_vars:
env['TERM'] =''

env.update(env_vars)
cmd_line.extend(args)
proc=subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
env=env, cwd=cwd)
withproc:
try:
out, err=proc.communicate()
finally:
proc.kill()
subprocess._cleanup()
rc=proc.returncode
err=strip_python_stderr(err)
return_PythonRunResult(rc, out, err), cmd_line

def_assert_python(expected_success, *args, **env_vars):
res, cmd_line=run_python_until_end(*args, **env_vars)
if (res.rcandexpected_success) or (notres.rcandnotexpected_success):
res.fail(cmd_line)
returnres

defassert_python_ok(*args, **env_vars):
"""
 Assert that running the interpreter with `args` and optional environment
 variables `env_vars` succeeds (rc == 0) and return a (return code, stdout,
 stderr) tuple.

 If the __cleanenv keyword is set, env_vars is used as a fresh environment.

 Python is started in isolated mode (command line option -I),
 except if the __isolated keyword is set to False.
 """
return_assert_python(True, *args, **env_vars)

defassert_python_failure(*args, **env_vars):
"""
 Assert that running the interpreter with `args` and optional environment
 variables `env_vars` fails (rc != 0) and return a (return code, stdout,
 stderr) tuple.

 See assert_python_ok() for more options.
 """
return_assert_python(False, *args, **env_vars)

defspawn_python(*args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, **kw):
"""Run a Python subprocess with the given arguments.

 kw is extra keyword args to pass to subprocess.Popen. Returns a Popen
 object.
 """
cmd_line= [sys.executable]
ifnotinterpreter_requires_environment():
cmd_line.append('-E')
cmd_line.extend(args)
# Under Fedora (?), GNU readline can output junk on stderr when initialized,
# depending on the TERM setting. Setting TERM=vt100 is supposed to disable
# that. References:
# - http://reinout.vanrees.org/weblog/2009/08/14/readline-invisible-character-hack.html
# - http://stackoverflow.com/questions/15760712/python-readline-module-prints-escape-character-during-import
# - http://lists.gnu.org/archive/html/bug-readline/2007-08/msg00004.html
env=kw.setdefault('env', dict(os.environ))
env['TERM'] ='vt100'
returnsubprocess.Popen(cmd_line, stdin=subprocess.PIPE,
stdout=stdout, stderr=stderr,
**kw)

defkill_python(p):
"""Run the given Popen process until completion and return stdout."""
p.stdin.close()
data=p.stdout.read()
p.stdout.close()
# try to cleanup the child so we don't appear to leak when running
# with regrtest -R.
p.wait()
subprocess._cleanup()
returndata

defmake_script(script_dir, script_basename, source, omit_suffix=False):
script_filename=script_basename
ifnotomit_suffix:
script_filename+=os.extsep+'py'
script_name=os.path.join(script_dir, script_filename)
# The script should be encoded to UTF-8, the default string encoding
script_file=open(script_name, 'w', encoding='utf-8')
script_file.write(source)
script_file.close()
importlib.invalidate_caches()
returnscript_name

defmake_zip_script(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')
ifname_in_zipisNone:
parts=script_name.split(os.sep)
iflen(parts) >=2andparts[-2] =='__pycache__':
legacy_pyc=make_legacy_pyc(source_from_cache(script_name))
name_in_zip=os.path.basename(legacy_pyc)
script_name=legacy_pyc
else:
name_in_zip=os.path.basename(script_name)
zip_file.write(script_name, name_in_zip)
zip_file.close()
#if test.support.verbose:
# zip_file = zipfile.ZipFile(zip_name, 'r')
# print 'Contents of %r:' % zip_name
# zip_file.printdir()
# zip_file.close()
returnzip_name, os.path.join(zip_name, name_in_zip)

defmake_pkg(pkg_dir, init_source=''):
os.mkdir(pkg_dir)
make_script(pkg_dir, '__init__', init_source)

defmake_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename,
source, depth=1, compiled=False):
unlink= []
init_name=make_script(zip_dir, '__init__', '')
unlink.append(init_name)
init_basename=os.path.basename(init_name)
script_name=make_script(zip_dir, script_basename, source)
unlink.append(script_name)
ifcompiled:
init_name=py_compile.compile(init_name, doraise=True)
script_name=py_compile.compile(script_name, doraise=True)
unlink.extend((init_name, script_name))
pkg_names= [os.sep.join([pkg_name]*i) foriinrange(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')
fornameinpkg_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()
fornameinunlink:
os.unlink(name)
#if test.support.verbose:
# zip_file = zipfile.ZipFile(zip_name, 'r')
# print 'Contents of %r:' % zip_name
# zip_file.printdir()
# zip_file.close()
returnzip_name, os.path.join(zip_name, script_name_in_zip)