| import contextlib |
| import itertools |
| import os |
| import re |
| import shutil |
| import subprocess |
| import sys |
| import sysconfig |
| import tempfile |
| import unittest |
| from pathlib import Path |
| from test import support |
| |
| if sys.platform != "win32": |
| raise unittest.SkipTest("test only applies to Windows") |
| |
| # Get winreg after the platform check |
| import winreg |
| |
| |
| PY_EXE = "py.exe" |
| if sys.executable.casefold().endswith("_d.exe".casefold()): |
| PY_EXE = "py_d.exe" |
| |
| # Registry data to create. On removal, everything beneath top-level names will |
| # be deleted. |
| TEST_DATA = { |
| "PythonTestSuite": { |
| "DisplayName": "Python Test Suite", |
| "SupportUrl": "https://www.python.org/", |
| "3.100": { |
| "DisplayName": "X.Y version", |
| "InstallPath": { |
| None: sys.prefix, |
| "ExecutablePath": "X.Y.exe", |
| } |
| }, |
| "3.100-32": { |
| "DisplayName": "X.Y-32 version", |
| "InstallPath": { |
| None: sys.prefix, |
| "ExecutablePath": "X.Y-32.exe", |
| } |
| }, |
| "3.100-arm64": { |
| "DisplayName": "X.Y-arm64 version", |
| "InstallPath": { |
| None: sys.prefix, |
| "ExecutablePath": "X.Y-arm64.exe", |
| "ExecutableArguments": "-X fake_arg_for_test", |
| } |
| }, |
| "ignored": { |
| "DisplayName": "Ignored because no ExecutablePath", |
| "InstallPath": { |
| None: sys.prefix, |
| } |
| }, |
| }, |
| "PythonTestSuite1": { |
| "DisplayName": "Python Test Suite Single", |
| "3.100": { |
| "DisplayName": "Single Interpreter", |
| "InstallPath": { |
| None: sys.prefix, |
| "ExecutablePath": sys.executable, |
| } |
| } |
| }, |
| } |
| |
| |
| TEST_PY_ENV = dict( |
| PY_PYTHON="PythonTestSuite/3.100", |
| PY_PYTHON2="PythonTestSuite/3.100-32", |
| PY_PYTHON3="PythonTestSuite/3.100-arm64", |
| ) |
| |
| |
| TEST_PY_DEFAULTS = "\n".join([ |
| "[defaults]", |
| *[f"{k[3:].lower()}={v}" for k, v in TEST_PY_ENV.items()], |
| ]) |
| |
| |
| TEST_PY_COMMANDS = "\n".join([ |
| "[commands]", |
| "test-command=TEST_EXE.exe", |
| ]) |
| |
| def create_registry_data(root, data): |
| def _create_registry_data(root, key, value): |
| if isinstance(value, dict): |
| # For a dict, we recursively create keys |
| with winreg.CreateKeyEx(root, key) as hkey: |
| for k, v in value.items(): |
| _create_registry_data(hkey, k, v) |
| elif isinstance(value, str): |
| # For strings, we set values. 'key' may be None in this case |
| winreg.SetValueEx(root, key, None, winreg.REG_SZ, value) |
| else: |
| raise TypeError("don't know how to create data for '{}'".format(value)) |
| |
| for k, v in data.items(): |
| _create_registry_data(root, k, v) |
| |
| |
| def enum_keys(root): |
| for i in itertools.count(): |
| try: |
| yield winreg.EnumKey(root, i) |
| except OSError as ex: |
| if ex.winerror == 259: |
| break |
| raise |
| |
| |
| def delete_registry_data(root, keys): |
| ACCESS = winreg.KEY_WRITE | winreg.KEY_ENUMERATE_SUB_KEYS |
| for key in list(keys): |
| with winreg.OpenKey(root, key, access=ACCESS) as hkey: |
| delete_registry_data(hkey, enum_keys(hkey)) |
| winreg.DeleteKey(root, key) |
| |
| |
| def is_installed(tag): |
| key = rf"Software\Python\PythonCore\{tag}\InstallPath" |
| for root, flag in [ |
| (winreg.HKEY_CURRENT_USER, 0), |
| (winreg.HKEY_LOCAL_MACHINE, winreg.KEY_WOW64_64KEY), |
| (winreg.HKEY_LOCAL_MACHINE, winreg.KEY_WOW64_32KEY), |
| ]: |
| try: |
| winreg.CloseKey(winreg.OpenKey(root, key, access=winreg.KEY_READ | flag)) |
| return True |
| except OSError: |
| pass |
| return False |
| |
| |
| class PreservePyIni: |
| def __init__(self, path, content): |
| self.path = Path(path) |
| self.content = content |
| self._preserved = None |
| |
| def __enter__(self): |
| try: |
| self._preserved = self.path.read_bytes() |
| except FileNotFoundError: |
| self._preserved = None |
| self.path.write_text(self.content, encoding="utf-16") |
| |
| def __exit__(self, *exc_info): |
| if self._preserved is None: |
| self.path.unlink() |
| else: |
| self.path.write_bytes(self._preserved) |
| |
| |
| class RunPyMixin: |
| py_exe = None |
| |
| @classmethod |
| def find_py(cls): |
| py_exe = None |
| if sysconfig.is_python_build(): |
| py_exe = Path(sys.executable).parent / PY_EXE |
| else: |
| for p in os.getenv("PATH").split(";"): |
| if p: |
| py_exe = Path(p) / PY_EXE |
| if py_exe.is_file(): |
| break |
| else: |
| py_exe = None |
| |
| # Test launch and check version, to exclude installs of older |
| # releases when running outside of a source tree |
| if py_exe: |
| try: |
| with subprocess.Popen( |
| [py_exe, "-h"], |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| encoding="ascii", |
| errors="ignore", |
| ) as p: |
| p.stdin.close() |
| version = next(p.stdout, "\n").splitlines()[0].rpartition(" ")[2] |
| p.stdout.read() |
| p.wait(10) |
| if not sys.version.startswith(version): |
| py_exe = None |
| except OSError: |
| py_exe = None |
| |
| if not py_exe: |
| raise unittest.SkipTest( |
| "cannot locate '{}' for test".format(PY_EXE) |
| ) |
| return py_exe |
| |
| def get_py_exe(self): |
| if not self.py_exe: |
| self.py_exe = self.find_py() |
| return self.py_exe |
| |
| def run_py(self, args, env=None, allow_fail=False, expect_returncode=0, argv=None): |
| if not self.py_exe: |
| self.py_exe = self.find_py() |
| |
| ignore = {"VIRTUAL_ENV", "PY_PYTHON", "PY_PYTHON2", "PY_PYTHON3"} |
| env = { |
| **{k.upper(): v for k, v in os.environ.items() if k.upper() not in ignore}, |
| "PYLAUNCHER_DEBUG": "1", |
| "PYLAUNCHER_DRYRUN": "1", |
| "PYLAUNCHER_LIMIT_TO_COMPANY": "", |
| **{k.upper(): v for k, v in (env or {}).items()}, |
| } |
| if not argv: |
| argv = [self.py_exe, *args] |
| with subprocess.Popen( |
| argv, |
| env=env, |
| executable=self.py_exe, |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| ) as p: |
| p.stdin.close() |
| p.wait(10) |
| out = p.stdout.read().decode("utf-8", "replace") |
| err = p.stderr.read().decode("ascii", "replace") |
| if p.returncode != expect_returncode and support.verbose and not allow_fail: |
| print("++ COMMAND ++") |
| print([self.py_exe, *args]) |
| print("++ STDOUT ++") |
| print(out) |
| print("++ STDERR ++") |
| print(err) |
| if allow_fail and p.returncode != expect_returncode: |
| raise subprocess.CalledProcessError(p.returncode, [self.py_exe, *args], out, err) |
| else: |
| self.assertEqual(expect_returncode, p.returncode) |
| data = { |
| s.partition(":")[0]: s.partition(":")[2].lstrip() |
| for s in err.splitlines() |
| if not s.startswith("#") and ":" in s |
| } |
| data["stdout"] = out |
| data["stderr"] = err |
| return data |
| |
| def py_ini(self, content): |
| local_appdata = os.environ.get("LOCALAPPDATA") |
| if not local_appdata: |
| raise unittest.SkipTest("LOCALAPPDATA environment variable is " |
| "missing or empty") |
| return PreservePyIni(Path(local_appdata) / "py.ini", content) |
| |
| @contextlib.contextmanager |
| def script(self, content, encoding="utf-8"): |
| file = Path(tempfile.mktemp(dir=os.getcwd()) + ".py") |
| file.write_text(content, encoding=encoding) |
| try: |
| yield file |
| finally: |
| file.unlink() |
| |
| @contextlib.contextmanager |
| def fake_venv(self): |
| venv = Path.cwd() / "Scripts" |
| venv.mkdir(exist_ok=True, parents=True) |
| venv_exe = (venv / Path(sys.executable).name) |
| venv_exe.touch() |
| try: |
| yield venv_exe, {"VIRTUAL_ENV": str(venv.parent)} |
| finally: |
| shutil.rmtree(venv) |
| |
| |
| class TestLauncher(unittest.TestCase, RunPyMixin): |
| @classmethod |
| def setUpClass(cls): |
| with winreg.CreateKey(winreg.HKEY_CURRENT_USER, rf"Software\Python") as key: |
| create_registry_data(key, TEST_DATA) |
| |
| if support.verbose: |
| p = subprocess.check_output("reg query HKCU\\Software\\Python /s") |
| #print(p.decode('mbcs')) |
| |
| |
| @classmethod |
| def tearDownClass(cls): |
| with winreg.OpenKey(winreg.HKEY_CURRENT_USER, rf"Software\Python", access=winreg.KEY_WRITE | winreg.KEY_ENUMERATE_SUB_KEYS) as key: |
| delete_registry_data(key, TEST_DATA) |
| |
| |
| def test_version(self): |
| data = self.run_py(["-0"]) |
| self.assertEqual(self.py_exe, Path(data["argv0"])) |
| self.assertEqual(sys.version.partition(" ")[0], data["version"]) |
| |
| def test_help_option(self): |
| data = self.run_py(["-h"]) |
| self.assertEqual("True", data["SearchInfo.help"]) |
| |
| def test_list_option(self): |
| for opt, v1, v2 in [ |
| ("-0", "True", "False"), |
| ("-0p", "False", "True"), |
| ("--list", "True", "False"), |
| ("--list-paths", "False", "True"), |
| ]: |
| with self.subTest(opt): |
| data = self.run_py([opt]) |
| self.assertEqual(v1, data["SearchInfo.list"]) |
| self.assertEqual(v2, data["SearchInfo.listPaths"]) |
| |
| def test_list(self): |
| data = self.run_py(["--list"]) |
| found = {} |
| expect = {} |
| for line in data["stdout"].splitlines(): |
| m = re.match(r"\s*(.+?)\s+?(\*\s+)?(.+)$", line) |
| if m: |
| found[m.group(1)] = m.group(3) |
| for company in TEST_DATA: |
| company_data = TEST_DATA[company] |
| tags = [t for t in company_data if isinstance(company_data[t], dict)] |
| for tag in tags: |
| arg = f"-V:{company}/{tag}" |
| expect[arg] = company_data[tag]["DisplayName"] |
| expect.pop(f"-V:{company}/ignored", None) |
| |
| actual = {k: v for k, v in found.items() if k in expect} |
| try: |
| self.assertDictEqual(expect, actual) |
| except: |
| if support.verbose: |
| print("*** STDOUT ***") |
| print(data["stdout"]) |
| raise |
| |
| def test_list_paths(self): |
| data = self.run_py(["--list-paths"]) |
| found = {} |
| expect = {} |
| for line in data["stdout"].splitlines(): |
| m = re.match(r"\s*(.+?)\s+?(\*\s+)?(.+)$", line) |
| if m: |
| found[m.group(1)] = m.group(3) |
| for company in TEST_DATA: |
| company_data = TEST_DATA[company] |
| tags = [t for t in company_data if isinstance(company_data[t], dict)] |
| for tag in tags: |
| arg = f"-V:{company}/{tag}" |
| install = company_data[tag]["InstallPath"] |
| try: |
| expect[arg] = install["ExecutablePath"] |
| try: |
| expect[arg] += " " + install["ExecutableArguments"] |
| except KeyError: |
| pass |
| except KeyError: |
| expect[arg] = str(Path(install[None]) / Path(sys.executable).name) |
| |
| expect.pop(f"-V:{company}/ignored", None) |
| |
| actual = {k: v for k, v in found.items() if k in expect} |
| try: |
| self.assertDictEqual(expect, actual) |
| except: |
| if support.verbose: |
| print("*** STDOUT ***") |
| print(data["stdout"]) |
| raise |
| |
| def test_filter_to_company(self): |
| company = "PythonTestSuite" |
| data = self.run_py([f"-V:{company}/"]) |
| self.assertEqual("X.Y.exe", data["LaunchCommand"]) |
| self.assertEqual(company, data["env.company"]) |
| self.assertEqual("3.100", data["env.tag"]) |
| |
| def test_filter_to_company_with_default(self): |
| company = "PythonTestSuite" |
| data = self.run_py([f"-V:{company}/"], env=dict(PY_PYTHON="3.0")) |
| self.assertEqual("X.Y.exe", data["LaunchCommand"]) |
| self.assertEqual(company, data["env.company"]) |
| self.assertEqual("3.100", data["env.tag"]) |
| |
| def test_filter_to_tag(self): |
| company = "PythonTestSuite" |
| data = self.run_py([f"-V:3.100"]) |
| self.assertEqual("X.Y.exe", data["LaunchCommand"]) |
| self.assertEqual(company, data["env.company"]) |
| self.assertEqual("3.100", data["env.tag"]) |
| |
| data = self.run_py([f"-V:3.100-32"]) |
| self.assertEqual("X.Y-32.exe", data["LaunchCommand"]) |
| self.assertEqual(company, data["env.company"]) |
| self.assertEqual("3.100-32", data["env.tag"]) |
| |
| data = self.run_py([f"-V:3.100-arm64"]) |
| self.assertEqual("X.Y-arm64.exe -X fake_arg_for_test", data["LaunchCommand"]) |
| self.assertEqual(company, data["env.company"]) |
| self.assertEqual("3.100-arm64", data["env.tag"]) |
| |
| def test_filter_to_company_and_tag(self): |
| company = "PythonTestSuite" |
| data = self.run_py([f"-V:{company}/3.1"], expect_returncode=103) |
| |
| data = self.run_py([f"-V:{company}/3.100"]) |
| self.assertEqual("X.Y.exe", data["LaunchCommand"]) |
| self.assertEqual(company, data["env.company"]) |
| self.assertEqual("3.100", data["env.tag"]) |
| |
| def test_filter_with_single_install(self): |
| company = "PythonTestSuite1" |
| data = self.run_py( |
| [f"-V:Nonexistent"], |
| env={"PYLAUNCHER_LIMIT_TO_COMPANY": company}, |
| expect_returncode=103, |
| ) |
| |
| def test_search_major_3(self): |
| try: |
| data = self.run_py(["-3"], allow_fail=True) |
| except subprocess.CalledProcessError: |
| raise unittest.SkipTest("requires at least one Python 3.x install") |
| self.assertEqual("PythonCore", data["env.company"]) |
| self.assertTrue(data["env.tag"].startswith("3."), data["env.tag"]) |
| |
| def test_search_major_3_32(self): |
| try: |
| data = self.run_py(["-3-32"], allow_fail=True) |
| except subprocess.CalledProcessError: |
| if not any(is_installed(f"3.{i}-32") for i in range(5, 11)): |
| raise unittest.SkipTest("requires at least one 32-bit Python 3.x install") |
| raise |
| self.assertEqual("PythonCore", data["env.company"]) |
| self.assertTrue(data["env.tag"].startswith("3."), data["env.tag"]) |
| self.assertTrue(data["env.tag"].endswith("-32"), data["env.tag"]) |
| |
| def test_search_major_2(self): |
| try: |
| data = self.run_py(["-2"], allow_fail=True) |
| except subprocess.CalledProcessError: |
| if not is_installed("2.7"): |
| raise unittest.SkipTest("requires at least one Python 2.x install") |
| self.assertEqual("PythonCore", data["env.company"]) |
| self.assertTrue(data["env.tag"].startswith("2."), data["env.tag"]) |
| |
| def test_py_default(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| data = self.run_py(["-arg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100", data["SearchInfo.tag"]) |
| self.assertEqual("X.Y.exe -arg", data["stdout"].strip()) |
| |
| def test_py2_default(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| data = self.run_py(["-2", "-arg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100-32", data["SearchInfo.tag"]) |
| self.assertEqual("X.Y-32.exe -arg", data["stdout"].strip()) |
| |
| def test_py3_default(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| data = self.run_py(["-3", "-arg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100-arm64", data["SearchInfo.tag"]) |
| self.assertEqual("X.Y-arm64.exe -X fake_arg_for_test -arg", data["stdout"].strip()) |
| |
| def test_py_default_env(self): |
| data = self.run_py(["-arg"], env=TEST_PY_ENV) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100", data["SearchInfo.tag"]) |
| self.assertEqual("X.Y.exe -arg", data["stdout"].strip()) |
| |
| def test_py2_default_env(self): |
| data = self.run_py(["-2", "-arg"], env=TEST_PY_ENV) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100-32", data["SearchInfo.tag"]) |
| self.assertEqual("X.Y-32.exe -arg", data["stdout"].strip()) |
| |
| def test_py3_default_env(self): |
| data = self.run_py(["-3", "-arg"], env=TEST_PY_ENV) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100-arm64", data["SearchInfo.tag"]) |
| self.assertEqual("X.Y-arm64.exe -X fake_arg_for_test -arg", data["stdout"].strip()) |
| |
| def test_py_default_short_argv0(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| for argv0 in ['"py.exe"', 'py.exe', '"py"', 'py']: |
| with self.subTest(argv0): |
| data = self.run_py(["--version"], argv=f'{argv0} --version') |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100", data["SearchInfo.tag"]) |
| self.assertEqual(f'X.Y.exe --version', data["stdout"].strip()) |
| |
| def test_py_default_in_list(self): |
| data = self.run_py(["-0"], env=TEST_PY_ENV) |
| default = None |
| for line in data["stdout"].splitlines(): |
| m = re.match(r"\s*-V:(.+?)\s+?\*\s+(.+)$", line) |
| if m: |
| default = m.group(1) |
| break |
| self.assertEqual("PythonTestSuite/3.100", default) |
| |
| def test_virtualenv_in_list(self): |
| with self.fake_venv() as (venv_exe, env): |
| data = self.run_py(["-0p"], env=env) |
| for line in data["stdout"].splitlines(): |
| m = re.match(r"\s*\*\s+(.+)$", line) |
| if m: |
| self.assertEqual(str(venv_exe), m.group(1)) |
| break |
| else: |
| self.fail("did not find active venv path") |
| |
| data = self.run_py(["-0"], env=env) |
| for line in data["stdout"].splitlines(): |
| m = re.match(r"\s*\*\s+(.+)$", line) |
| if m: |
| self.assertEqual("Active venv", m.group(1)) |
| break |
| else: |
| self.fail("did not find active venv entry") |
| |
| def test_virtualenv_with_env(self): |
| with self.fake_venv() as (venv_exe, env): |
| data1 = self.run_py([], env={**env, "PY_PYTHON": "PythonTestSuite/3"}) |
| data2 = self.run_py(["-V:PythonTestSuite/3"], env={**env, "PY_PYTHON": "PythonTestSuite/3"}) |
| # Compare stdout, because stderr goes via ascii |
| self.assertEqual(data1["stdout"].strip(), str(venv_exe)) |
| self.assertEqual(data1["SearchInfo.lowPriorityTag"], "True") |
| # Ensure passing the argument doesn't trigger the same behaviour |
| self.assertNotEqual(data2["stdout"].strip(), str(venv_exe)) |
| self.assertNotEqual(data2["SearchInfo.lowPriorityTag"], "True") |
| |
| def test_py_shebang(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script("#! /usr/bin/python -prearg") as script: |
| data = self.run_py([script, "-postarg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100", data["SearchInfo.tag"]) |
| self.assertEqual(f"X.Y.exe -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_python_shebang(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script("#! python -prearg") as script: |
| data = self.run_py([script, "-postarg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100", data["SearchInfo.tag"]) |
| self.assertEqual(f"X.Y.exe -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_py2_shebang(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script("#! /usr/bin/python2 -prearg") as script: |
| data = self.run_py([script, "-postarg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100-32", data["SearchInfo.tag"]) |
| self.assertEqual(f"X.Y-32.exe -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_py3_shebang(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script("#! /usr/bin/python3 -prearg") as script: |
| data = self.run_py([script, "-postarg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100-arm64", data["SearchInfo.tag"]) |
| self.assertEqual(f"X.Y-arm64.exe -X fake_arg_for_test -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_py_shebang_nl(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script("#! /usr/bin/python -prearg\n") as script: |
| data = self.run_py([script, "-postarg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100", data["SearchInfo.tag"]) |
| self.assertEqual(f"X.Y.exe -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_py2_shebang_nl(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script("#! /usr/bin/python2 -prearg\n") as script: |
| data = self.run_py([script, "-postarg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100-32", data["SearchInfo.tag"]) |
| self.assertEqual(f"X.Y-32.exe -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_py3_shebang_nl(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script("#! /usr/bin/python3 -prearg\n") as script: |
| data = self.run_py([script, "-postarg"]) |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100-arm64", data["SearchInfo.tag"]) |
| self.assertEqual(f"X.Y-arm64.exe -X fake_arg_for_test -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_py_shebang_short_argv0(self): |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script("#! /usr/bin/python -prearg") as script: |
| # Override argv to only pass "py.exe" as the command |
| data = self.run_py([script, "-postarg"], argv=f'"py.exe" "{script}" -postarg') |
| self.assertEqual("PythonTestSuite", data["SearchInfo.company"]) |
| self.assertEqual("3.100", data["SearchInfo.tag"]) |
| self.assertEqual(f'X.Y.exe -prearg "{script}" -postarg', data["stdout"].strip()) |
| |
| def test_py_handle_64_in_ini(self): |
| with self.py_ini("\n".join(["[defaults]", "python=3.999-64"])): |
| # Expect this to fail, but should get oldStyleTag flipped on |
| data = self.run_py([], allow_fail=True, expect_returncode=103) |
| self.assertEqual("3.999-64", data["SearchInfo.tag"]) |
| self.assertEqual("True", data["SearchInfo.oldStyleTag"]) |
| |
| def test_search_path(self): |
| stem = Path(sys.executable).stem |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script(f"#! /usr/bin/env {stem} -prearg") as script: |
| data = self.run_py( |
| [script, "-postarg"], |
| env={"PATH": f"{Path(sys.executable).parent};{os.getenv('PATH')}"}, |
| ) |
| self.assertEqual(f"{sys.executable} -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_search_path_exe(self): |
| # Leave the .exe on the name to ensure we don't add it a second time |
| name = Path(sys.executable).name |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script(f"#! /usr/bin/env {name} -prearg") as script: |
| data = self.run_py( |
| [script, "-postarg"], |
| env={"PATH": f"{Path(sys.executable).parent};{os.getenv('PATH')}"}, |
| ) |
| self.assertEqual(f"{sys.executable} -prearg {script} -postarg", data["stdout"].strip()) |
| |
| def test_recursive_search_path(self): |
| stem = self.get_py_exe().stem |
| with self.py_ini(TEST_PY_DEFAULTS): |
| with self.script(f"#! /usr/bin/env {stem}") as script: |
| data = self.run_py( |
| [script], |
| env={"PATH": f"{self.get_py_exe().parent};{os.getenv('PATH')}"}, |
| ) |
| # The recursive search is ignored and we get normal "py" behavior |
| self.assertEqual(f"X.Y.exe {script}", data["stdout"].strip()) |
| |
| def test_install(self): |
| data = self.run_py(["-V:3.10"], env={"PYLAUNCHER_ALWAYS_INSTALL": "1"}, expect_returncode=111) |
| cmd = data["stdout"].strip() |
| # If winget is runnable, we should find it. Otherwise, we'll be trying |
| # to open the Store. |
| try: |
| subprocess.check_call(["winget.exe", "--version"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
| except FileNotFoundError: |
| self.assertIn("ms-windows-store://", cmd) |
| else: |
| self.assertIn("winget.exe", cmd) |
| # Both command lines include the store ID |
| self.assertIn("9PJPW5LDXLZ5", cmd) |
| |
| def test_literal_shebang_absolute(self): |
| with self.script(f"#! C:/some_random_app -witharg") as script: |
| data = self.run_py([script]) |
| self.assertEqual( |
| f"C:\\some_random_app -witharg {script}", |
| data["stdout"].strip(), |
| ) |
| |
| def test_literal_shebang_relative(self): |
| with self.script(f"#! ..\\some_random_app -witharg") as script: |
| data = self.run_py([script]) |
| self.assertEqual( |
| f"{script.parent.parent}\\some_random_app -witharg {script}", |
| data["stdout"].strip(), |
| ) |
| |
| def test_literal_shebang_quoted(self): |
| with self.script(f'#! "some random app" -witharg') as script: |
| data = self.run_py([script]) |
| self.assertEqual( |
| f'"{script.parent}\\some random app" -witharg {script}', |
| data["stdout"].strip(), |
| ) |
| |
| with self.script(f'#! some" random "app -witharg') as script: |
| data = self.run_py([script]) |
| self.assertEqual( |
| f'"{script.parent}\\some random app" -witharg {script}', |
| data["stdout"].strip(), |
| ) |
| |
| def test_literal_shebang_quoted_escape(self): |
| with self.script(f'#! some\\" random "app -witharg') as script: |
| data = self.run_py([script]) |
| self.assertEqual( |
| f'"{script.parent}\\some\\ random app" -witharg {script}', |
| data["stdout"].strip(), |
| ) |
| |
| def test_literal_shebang_command(self): |
| with self.py_ini(TEST_PY_COMMANDS): |
| with self.script('#! test-command arg1') as script: |
| data = self.run_py([script]) |
| self.assertEqual( |
| f"TEST_EXE.exe arg1 {script}", |
| data["stdout"].strip(), |
| ) |
| |
| def test_literal_shebang_invalid_template(self): |
| with self.script('#! /usr/bin/not-python arg1') as script: |
| data = self.run_py([script]) |
| expect = script.parent / "/usr/bin/not-python" |
| self.assertEqual( |
| f"{expect} arg1 {script}", |
| data["stdout"].strip(), |
| ) |
