Fix tests in test_compileall, test_import, test_importlib, test_py_compile, and test_inspect to neutralize PYTHONPYCACHEPREFIX
finally:
sys.pycache_prefix = old_prefix
+ @contextlib.contextmanager
+ def no_pycache_prefix(self):
+ """Ignore any ambient pycache prefix for the duration of the test.
+
+ Some tests assume bytecode is written next to the source in a
+ __pycache__ directory. When the test suite is run with
+ PYTHONPYCACHEPREFIX set, neutralize it both in this process (used by
+ cache_from_source) and in any spawned subprocesses.
+ """
+ old_prefix = sys.pycache_prefix
+ sys.pycache_prefix = None
+ try:
+ with os_helper.EnvironmentVarGuard() as env:
+ env.unset('PYTHONPYCACHEPREFIX')
+ yield
+ finally:
+ sys.pycache_prefix = old_prefix
+
def _get_run_args(self, args):
return [*support.optim_args_from_interpreter_flags(),
'-S', '-m', 'compileall',
def test_multiple_runs(self):
# Bug 8527 reported that multiple calls produced empty
# __pycache__/__pycache__ directories.
- self.assertRunOK('-q', self.pkgdir)
- # Verify the __pycache__ directory contents.
- self.assertTrue(os.path.exists(self.pkgdir_cachedir))
- cachecachedir = os.path.join(self.pkgdir_cachedir, '__pycache__')
- self.assertFalse(os.path.exists(cachecachedir))
- # Call compileall again.
- self.assertRunOK('-q', self.pkgdir)
- self.assertTrue(os.path.exists(self.pkgdir_cachedir))
- self.assertFalse(os.path.exists(cachecachedir))
+ with self.no_pycache_prefix():
+ self.assertRunOK('-q', self.pkgdir)
+ # Verify the __pycache__ directory contents.
+ self.assertTrue(os.path.exists(self.pkgdir_cachedir))
+ cachecachedir = os.path.join(self.pkgdir_cachedir, '__pycache__')
+ self.assertFalse(os.path.exists(cachecachedir))
+ # Call compileall again.
+ self.assertRunOK('-q', self.pkgdir)
+ self.assertTrue(os.path.exists(self.pkgdir_cachedir))
+ self.assertFalse(os.path.exists(cachecachedir))
@without_source_date_epoch # timestamp invalidation test
def test_force(self):
script_helper.make_pkg(pkg)
os.symlink('.', os.path.join(pkg, 'evil'))
os.symlink('.', os.path.join(pkg, 'evil2'))
- self.assertRunOK('-q', self.pkgdir)
- self.assertCompiled(os.path.join(
- self.pkgdir, 'spam', 'evil', 'evil2', '__init__.py'
- ))
+ # This relies on the __pycache__ layout (shared across the symlinked
+ # paths), so neutralize any ambient PYTHONPYCACHEPREFIX.
+ with self.no_pycache_prefix():
+ self.assertRunOK('-q', self.pkgdir)
+ self.assertCompiled(os.path.join(
+ self.pkgdir, 'spam', 'evil', 'evil2', '__init__.py'
+ ))
def test_quiet(self):
noisy = self.assertRunOK(self.pkgdir)
f2 = script_helper.make_script(self.pkgdir, 'f2', '')
f3 = script_helper.make_script(self.pkgdir, 'f3', '')
f4 = script_helper.make_script(self.pkgdir, 'f4', '')
- p = script_helper.spawn_python(*(self._get_run_args(()) + ['-i', '-']))
- p.stdin.write((f3+os.linesep).encode('ascii'))
- script_helper.kill_python(p)
- self.assertNotCompiled(f1)
- self.assertNotCompiled(f2)
- self.assertCompiled(f3)
- self.assertNotCompiled(f4)
+ # spawn_python() runs with -E, ignoring PYTHONPYCACHEPREFIX, so make
+ # cache_from_source() in this process agree by neutralizing it too.
+ with self.no_pycache_prefix():
+ p = script_helper.spawn_python(*(self._get_run_args(()) + ['-i', '-']))
+ p.stdin.write((f3+os.linesep).encode('ascii'))
+ script_helper.kill_python(p)
+ self.assertNotCompiled(f1)
+ self.assertNotCompiled(f2)
+ self.assertCompiled(f3)
+ self.assertNotCompiled(f4)
def test_compiles_as_much_as_possible(self):
bingfn = script_helper.make_script(self.pkgdir, 'bing', 'syntax(error')
unlink(self.source)
def setUp(self):
+ # These tests assume bytecode is written next to the source in a
+ # local __pycache__ directory, so neutralize any pycache prefix (e.g.
+ # when the test suite is run with PYTHONPYCACHEPREFIX set).
+ self._orig_pycache_prefix = sys.pycache_prefix
+ sys.pycache_prefix = None
self.source = TESTFN + '.py'
self._clean()
with open(self.source, 'w', encoding='utf-8') as fp:
assert sys.path[0] == os.curdir, 'Unexpected sys.path[0]'
del sys.path[0]
self._clean()
+ sys.pycache_prefix = self._orig_pycache_prefix
@skip_if_dont_write_bytecode
def test_import_pyc_path(self):
tag = sys.implementation.cache_tag
+ def setUp(self):
+ # Most of these tests assume the default (unset) pycache prefix, so
+ # clear it for the duration of the test (e.g. when the test suite is
+ # run with PYTHONPYCACHEPREFIX set). Tests that need a specific prefix
+ # set their own via util.temporary_pycache_prefix().
+ self._orig_pycache_prefix = sys.pycache_prefix
+ sys.pycache_prefix = None
+
+ def tearDown(self):
+ sys.pycache_prefix = self._orig_pycache_prefix
+
@unittest.skipIf(sys.implementation.cache_tag is None,
'requires sys.implementation.cache_tag not be None')
def test_cache_from_source(self):
import functools
import gc
import importlib
+import importlib.util
import inspect
import io
import linecache
NO_SOURCE_ERROR = "No source code available for defining module"
NO_SOURCE_TARGET_ERROR = "Failed to retrieve source code for given target"
+ @staticmethod
+ def _expected_cached(module):
+ # assert_python_ok() runs the subprocess in isolated mode (-I), which
+ # ignores PYTHONPYCACHEPREFIX, so compute the expected cached path the
+ # same way (i.e. without any pycache prefix) to stay independent of the
+ # environment the test suite is run in. Modules without a cached path
+ # (e.g. frozen modules such as ntpath/importlib.machinery on Windows)
+ # report None, so preserve that.
+ if module.__spec__.cached is None:
+ return None
+ with support.swap_attr(sys, 'pycache_prefix', None):
+ return importlib.util.cache_from_source(module.__spec__.origin)
+
def test_only_source(self):
module = importlib.import_module('unittest')
rc, out, err = assert_python_ok('-m', 'inspect',
args = support.optim_args_from_interpreter_flags()
rc, out, err = assert_python_ok(*args, '-m', 'inspect',
module_name, '--details')
+ cached = self._expected_cached(module)
# Full rendering check on the expected output
expected_lines = [
f"Target: {module.__name__}", # No aliasing
f"Origin: {module.__spec__.origin}",
f"Source: {module.__file__}",
- f"Cached: {module.__spec__.cached}", # None is still displayed
+ f"Cached: {cached}", # None is still displayed
f"Loader: {_clean_object_ids(repr(module.__spec__.loader))}",
f"Submodule search paths: {module.__path__}",
"",
args = support.optim_args_from_interpreter_flags()
rc, out, err = assert_python_ok(*args, '-m', 'inspect',
cli_target, '--details')
+ cached = self._expected_cached(module)
# Full rendering check on the expected output
# The error is only informational when reading source details
expected_lines = [
f"Target: {cli_target}", # No aliasing
f"Origin: {module.__spec__.origin}",
f"Source: {module.__file__}",
- f"Cached: {module.__spec__.cached}", # None is still displayed
+ f"Cached: {cached}", # None is still displayed
self.NO_SOURCE_TARGET_ERROR,
"",
]
args = support.optim_args_from_interpreter_flags()
rc, out, err = assert_python_ok(*args, '-m', 'inspect',
cli_target, '--details')
+ cached = self._expected_cached(module)
# Full rendering check on the expected output
expected_lines = [
f'Target: {defining_target} (looked up as "{cli_target}")',
f"Origin: {module.__spec__.origin}",
f"Source: {module.__file__}",
- f"Cached: {module.__spec__.cached}", # None is still displayed
+ f"Cached: {cached}", # None is still displayed
f"Line: {inspect.findsource(target)[1]}",
"",
]
def test_double_dot_no_clobber(self):
# http://bugs.python.org/issue22966
# py_compile foo.bar.py -> __pycache__/foo.cpython-34.pyc
- weird_path = os.path.join(self.directory, 'foo.bar.py')
- cache_path = importlib.util.cache_from_source(weird_path)
- pyc_path = weird_path + 'c'
- head, tail = os.path.split(cache_path)
- penultimate_tail = os.path.basename(head)
- self.assertEqual(
- os.path.join(penultimate_tail, tail),
- os.path.join(
- '__pycache__',
- 'foo.bar.{}.pyc'.format(sys.implementation.cache_tag)))
- with open(weird_path, 'w') as file:
- file.write('x = 123\n')
- py_compile.compile(weird_path)
- self.assertTrue(os.path.exists(cache_path))
- self.assertFalse(os.path.exists(pyc_path))
+ # This test asserts the default __pycache__ layout, so neutralize any
+ # pycache prefix (e.g. when run with PYTHONPYCACHEPREFIX set).
+ with support.swap_attr(sys, 'pycache_prefix', None):
+ weird_path = os.path.join(self.directory, 'foo.bar.py')
+ cache_path = importlib.util.cache_from_source(weird_path)
+ pyc_path = weird_path + 'c'
+ head, tail = os.path.split(cache_path)
+ penultimate_tail = os.path.basename(head)
+ self.assertEqual(
+ os.path.join(penultimate_tail, tail),
+ os.path.join(
+ '__pycache__',
+ 'foo.bar.{}.pyc'.format(sys.implementation.cache_tag)))
+ with open(weird_path, 'w') as file:
+ file.write('x = 123\n')
+ py_compile.compile(weird_path)
+ self.assertTrue(os.path.exists(cache_path))
+ self.assertFalse(os.path.exists(pyc_path))
@unittest.skipIf(sys.implementation.cache_tag is None,
'requires sys.implementation.cache_tag is not None')
self.assertEqual(rc, 0)
self.assertEqual(stdout, b'')
self.assertEqual(stderr, b'')
- self.assertTrue(os.path.exists(self.cache_path))
+ # pycompilecmd() runs the interpreter in isolated mode (-I), which
+ # ignores PYTHONPYCACHEPREFIX, so the bytecode is written next to the
+ # source. Compute the expected cache path the same way.
+ with support.swap_attr(sys, 'pycache_prefix', None):
+ cache_path = importlib.util.cache_from_source(
+ self.source_path, optimization='' if __debug__ else 1)
+ self.assertTrue(os.path.exists(cache_path))
def test_bad_syntax(self):
bad_syntax = os.path.join(os.path.dirname(__file__),
--- /dev/null
+Fix several tests in ``test.test_inspect``, ``test.test_import``,
+``test.test_importlib``, ``test.test_py_compile`` and
+``test.test_compileall`` that failed when the test suite was run with
+:envvar:`PYTHONPYCACHEPREFIX` set. These tests now neutralize the pycache
+prefix where they assume the default ``__pycache__`` bytecode layout.
projects / thirdparty / Python / cpython.git / commitdiff
