xavierk
80a3792576
Import the vocalinux source tree (tray app, Next.js site in web/, packaging, installers, docs and tests) on top of the Gitea template commit. The project README replaces the template README, and the template CI files (.gitea/workflows/ci.yml, .jscpd.json, CI.md) are kept.
355 lines
14 KiB
Python
355 lines
14 KiB
Python
"""Behavioral tests for the installer's Python interpreter selection.
|
|
|
|
Regression cover for the "Distro PyGObject is not importable in the venv"
|
|
failure: running install.sh from an activated virtualenv (e.g. uv's .venv left
|
|
active after `just deps`) made it build venv/ from that interpreter, where the
|
|
distro's gi is invisible.
|
|
"""
|
|
|
|
import re
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
INSTALL_SH = Path(__file__).resolve().parents[1] / "install.sh"
|
|
|
|
PRELUDE = """
|
|
set -uo pipefail
|
|
|
|
print_info() { echo "INFO: $*"; }
|
|
print_warning() { echo "WARNING: $*"; }
|
|
print_error() { echo "ERROR: $*"; }
|
|
print_success() { echo "SUCCESS: $*"; }
|
|
command_exists() { command -v "$1" >/dev/null 2>&1; }
|
|
"""
|
|
|
|
|
|
def _source(*functions: str) -> str:
|
|
"""Source the named function definitions out of install.sh."""
|
|
return "\n".join(
|
|
f"source <(sed -n '/^{name}() {{$/,/^}}$/p' \"{INSTALL_SH}\")" for name in functions
|
|
)
|
|
|
|
|
|
def _run(script: str) -> subprocess.CompletedProcess:
|
|
return subprocess.run(
|
|
["bash", "-c", PRELUDE + script], capture_output=True, text=True, timeout=30
|
|
)
|
|
|
|
|
|
def _fake_python(path: Path, version: str, has_gi: bool, base_prefix: str = "") -> Path:
|
|
"""Create a stub interpreter answering the probes install.sh runs.
|
|
|
|
``base_prefix`` defaults to the stub's own directory, so two stubs are
|
|
distinct installations unless they are told to share one.
|
|
"""
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(
|
|
"#!/bin/bash\n"
|
|
'if [[ "$*" == *"sys.version_info"* ]]; then\n'
|
|
f' echo "{version}"\n'
|
|
" exit 0\n"
|
|
"fi\n"
|
|
'if [[ "$*" == *"sys.base_prefix"* ]]; then\n'
|
|
f' echo "{base_prefix or path.parent}"\n'
|
|
" exit 0\n"
|
|
"fi\n"
|
|
'if [[ "$*" == *"import gi"* ]]; then\n'
|
|
f" exit {0 if has_gi else 1}\n"
|
|
"fi\n"
|
|
"exit 0\n"
|
|
)
|
|
path.chmod(0o755)
|
|
return path
|
|
|
|
|
|
class TestDeactivateInheritedVirtualenv:
|
|
def test_removes_active_venv_from_path(self, tmp_path):
|
|
venv = tmp_path / "venv"
|
|
(venv / "bin").mkdir(parents=True)
|
|
|
|
script = f"""
|
|
{_source("deactivate_inherited_virtualenv")}
|
|
export VIRTUAL_ENV="{venv}"
|
|
export PATH="{venv}/bin:/usr/bin:/bin"
|
|
deactivate_inherited_virtualenv
|
|
echo "PATH=$PATH"
|
|
echo "VIRTUAL_ENV=${{VIRTUAL_ENV:-<unset>}}"
|
|
"""
|
|
result = _run(script)
|
|
assert "PATH=/usr/bin:/bin" in result.stdout
|
|
assert "VIRTUAL_ENV=<unset>" in result.stdout
|
|
|
|
def test_removes_trailing_slash_venv_and_repeats(self, tmp_path):
|
|
venv = tmp_path / "venv"
|
|
(venv / "bin").mkdir(parents=True)
|
|
|
|
script = f"""
|
|
{_source("deactivate_inherited_virtualenv")}
|
|
export VIRTUAL_ENV="{venv}/"
|
|
export PATH="{venv}/bin:/usr/bin:{venv}/bin:/bin"
|
|
deactivate_inherited_virtualenv
|
|
echo "PATH=$PATH"
|
|
"""
|
|
result = _run(script)
|
|
assert "PATH=/usr/bin:/bin" in result.stdout
|
|
|
|
def test_no_active_venv_leaves_path_alone(self):
|
|
script = f"""
|
|
{_source("deactivate_inherited_virtualenv")}
|
|
unset VIRTUAL_ENV
|
|
export PATH="/usr/bin:/bin"
|
|
deactivate_inherited_virtualenv
|
|
echo "PATH=$PATH"
|
|
"""
|
|
result = _run(script)
|
|
assert "PATH=/usr/bin:/bin" in result.stdout
|
|
assert "WARNING" not in result.stdout
|
|
|
|
|
|
class TestSelectPythonInterpreter:
|
|
@staticmethod
|
|
def _select(path_python: Path, system_python: Path, min_version: str = "3.9") -> str:
|
|
script = f"""
|
|
PYTHON_CMD="python3"
|
|
SYSTEM_PYTHON="{system_python}"
|
|
{_source("python_version_of", "python_version_at_least", "python_has_gi", "select_python_interpreter")}
|
|
# Keep the system bin dirs: the fake interpreters shadow python3, while
|
|
# sort/head that select_python_interpreter relies on stay reachable.
|
|
export PATH="{path_python.parent}:/usr/bin:/bin"
|
|
select_python_interpreter "{min_version}" && echo "SELECTED=$PYTHON_CMD" || echo "SELECT_FAILED"
|
|
"""
|
|
return _run(script).stdout
|
|
|
|
def test_prefers_system_python_when_path_python_lacks_gi(self, tmp_path):
|
|
# The reported failure: PATH points at uv's 3.13 venv without gi while
|
|
# the distro built PyGObject for the system 3.14.
|
|
path_python = _fake_python(tmp_path / "pathbin" / "python3", "3.13", has_gi=False)
|
|
system_python = _fake_python(tmp_path / "usrbin" / "python3", "3.14", has_gi=True)
|
|
|
|
assert f"SELECTED={system_python}" in self._select(path_python, system_python)
|
|
|
|
def test_keeps_path_python_when_it_has_gi(self, tmp_path):
|
|
path_python = _fake_python(tmp_path / "pathbin" / "python3", "3.14", has_gi=True)
|
|
system_python = _fake_python(tmp_path / "usrbin" / "python3", "3.14", has_gi=True)
|
|
|
|
assert f"SELECTED={path_python}" in self._select(path_python, system_python)
|
|
|
|
def test_falls_back_to_the_system_python_when_no_candidate_has_gi(self, tmp_path):
|
|
# gi is usually installed later in the same run, so the fallback has to
|
|
# pick the interpreter that PyGObject will land on. Picking the PATH one
|
|
# here is exactly the venv-cannot-import-gi bug this file covers.
|
|
path_python = _fake_python(tmp_path / "pathbin" / "python3", "3.13", has_gi=False)
|
|
system_python = _fake_python(tmp_path / "usrbin" / "python3", "3.14", has_gi=False)
|
|
|
|
stdout = self._select(path_python, system_python)
|
|
assert f"SELECTED={system_python}" in stdout
|
|
|
|
def test_falls_back_to_path_python_when_the_system_one_is_too_old(self, tmp_path):
|
|
"""Preferring the system interpreter must not override the floor."""
|
|
path_python = _fake_python(tmp_path / "pathbin" / "python3", "3.12", has_gi=False)
|
|
system_python = _fake_python(tmp_path / "usrbin" / "python3", "3.9", has_gi=False)
|
|
|
|
stdout = self._select(path_python, system_python, min_version="3.11")
|
|
assert f"SELECTED={path_python}" in stdout
|
|
assert "SELECTED=python3" not in stdout
|
|
|
|
def test_skips_python_below_minimum_version(self, tmp_path):
|
|
too_old = _fake_python(tmp_path / "pathbin" / "python3", "3.6", has_gi=True)
|
|
system_python = _fake_python(tmp_path / "usrbin" / "python3", "3.14", has_gi=False)
|
|
|
|
assert f"SELECTED={system_python}" in self._select(too_old, system_python)
|
|
|
|
def test_reports_failure_when_no_python_exists(self, tmp_path):
|
|
empty_bin = tmp_path / "empty"
|
|
empty_bin.mkdir()
|
|
|
|
script = f"""
|
|
PYTHON_CMD="python3"
|
|
SYSTEM_PYTHON="{tmp_path}/missing-python3"
|
|
{_source("python_version_of", "python_version_at_least", "python_has_gi", "select_python_interpreter")}
|
|
export PATH="{empty_bin}"
|
|
select_python_interpreter "3.9" && echo "SELECTED=$PYTHON_CMD" || echo "SELECT_FAILED"
|
|
"""
|
|
assert "SELECT_FAILED" in _run(script).stdout
|
|
|
|
|
|
class TestVenvMatchesSelectedPython:
|
|
def test_venv_built_from_the_selected_interpreter(self, tmp_path):
|
|
base = str(tmp_path / "usr")
|
|
venv_python = _fake_python(
|
|
tmp_path / "venv" / "bin" / "python", "3.14", has_gi=True, base_prefix=base
|
|
)
|
|
selected = _fake_python(tmp_path / "usr" / "python3", "3.14", has_gi=True, base_prefix=base)
|
|
|
|
script = f"""
|
|
VENV_DIR="{venv_python.parents[1]}"
|
|
PYTHON_CMD="{selected}"
|
|
{_source("python_base_prefix", "venv_matches_selected_python")}
|
|
venv_matches_selected_python && echo "MATCH" || echo "MISMATCH"
|
|
"""
|
|
result = _run(script)
|
|
assert "MATCH" in result.stdout
|
|
|
|
def test_stale_venv_from_other_interpreter(self, tmp_path):
|
|
venv_python = _fake_python(tmp_path / "venv" / "bin" / "python", "3.13", has_gi=False)
|
|
selected = _fake_python(tmp_path / "usr" / "python3", "3.14", has_gi=True)
|
|
|
|
script = f"""
|
|
VENV_DIR="{venv_python.parents[1]}"
|
|
PYTHON_CMD="{selected}"
|
|
{_source("python_base_prefix", "venv_matches_selected_python")}
|
|
venv_matches_selected_python && echo "MATCH" || echo "MISMATCH"
|
|
"""
|
|
result = _run(script)
|
|
assert "MISMATCH" in result.stdout
|
|
|
|
def test_same_version_from_a_different_installation_is_stale(self, tmp_path):
|
|
"""A distro 3.12 and a pyenv/uv 3.12 are not interchangeable."""
|
|
venv_python = _fake_python(
|
|
tmp_path / "venv" / "bin" / "python",
|
|
"3.12",
|
|
has_gi=False,
|
|
base_prefix=str(tmp_path / "pyenv"),
|
|
)
|
|
selected = _fake_python(
|
|
tmp_path / "usr" / "python3", "3.12", has_gi=True, base_prefix="/usr"
|
|
)
|
|
|
|
script = f"""
|
|
VENV_DIR="{venv_python.parents[1]}"
|
|
PYTHON_CMD="{selected}"
|
|
{_source("python_base_prefix", "venv_matches_selected_python")}
|
|
venv_matches_selected_python && echo "MATCH" || echo "MISMATCH"
|
|
"""
|
|
result = _run(script)
|
|
assert "MISMATCH" in result.stdout
|
|
|
|
def test_missing_venv_python(self, tmp_path):
|
|
selected = _fake_python(tmp_path / "usr" / "python3", "3.14", has_gi=True)
|
|
|
|
script = f"""
|
|
VENV_DIR="{tmp_path}/nonexistent"
|
|
PYTHON_CMD="{selected}"
|
|
{_source("python_base_prefix", "venv_matches_selected_python")}
|
|
venv_matches_selected_python && echo "MATCH" || echo "MISMATCH"
|
|
"""
|
|
result = _run(script)
|
|
assert "MISMATCH" in result.stdout
|
|
|
|
|
|
class TestTheFloorIsTheInterpreterNotTheReleaseLabel:
|
|
"""Any distro that ships a new enough Python must be installable.
|
|
|
|
The installer used to reject the Ubuntu family on `VERSION_ID` alone. That
|
|
label is not the requirement and derivatives do not share Ubuntu's numbering:
|
|
Linux Mint 22 and elementary OS 8 are built on Ubuntu 24.04 and ship Python
|
|
3.12, yet report "22" and "8", which sort below "24.04".
|
|
"""
|
|
|
|
# The two shapes that matter, both handed an interpreter at 3.12: a label
|
|
# that sorts below the base release, and one that is not a release number at
|
|
# all. Pop!_OS and Kubuntu need no case of their own — they use Ubuntu's
|
|
# numbering, so they were never the ones being turned away.
|
|
DERIVATIVES = [
|
|
("linuxmint", "22"),
|
|
("elementary", "8"),
|
|
]
|
|
|
|
#: Family name in install.sh -> how docs/DISTRO_COMPATIBILITY.md spells it.
|
|
SUPPORTED_FAMILIES = {
|
|
"ubuntu": "Ubuntu",
|
|
"debian": "Debian",
|
|
"fedora": "Fedora",
|
|
"arch": "Arch Linux",
|
|
"suse": "openSUSE",
|
|
}
|
|
|
|
def test_a_documented_family_is_never_met_with_untested(self):
|
|
"""Fedora, Arch and openSUSE used to get the Ubuntu/Debian-only warning.
|
|
|
|
That warning ends in a y/n prompt which exits on "n", so a distro the
|
|
project documents as supported, and in Fedora's case builds in the distro
|
|
matrix, could be talked out of installing.
|
|
"""
|
|
source = INSTALL_SH.read_text(encoding="utf-8")
|
|
block = source[source.index("# Check compatibility") :]
|
|
block = block[: block.index("\nesac\n")]
|
|
|
|
arms = set()
|
|
for line in block.splitlines():
|
|
match = re.fullmatch(r"\s*([a-z|]+)\)", line)
|
|
if match:
|
|
arms.update(match.group(1).split("|"))
|
|
|
|
assert arms == set(self.SUPPORTED_FAMILIES), f"unexpected support tiers: {sorted(arms)}"
|
|
|
|
def test_the_installer_and_the_compatibility_doc_agree(self):
|
|
doc = (INSTALL_SH.parent / "docs" / "DISTRO_COMPATIBILITY.md").read_text(encoding="utf-8")
|
|
supported = doc[: doc.index("## Experimental Support")]
|
|
missing = [
|
|
name for name in self.SUPPORTED_FAMILIES.values() if f"| {name} |" not in supported
|
|
]
|
|
assert not missing, f"install.sh calls these supported, the doc does not: {missing}"
|
|
|
|
def test_no_supported_distro_is_filed_under_experimental(self):
|
|
"""The two tables have to mean what their headings say.
|
|
|
|
Linux Mint, Pop!_OS, elementary, Zorin, Manjaro and EndeavourOS sat in
|
|
"Experimental Support" while marked "Good Support", which is where the
|
|
installer's own idea of who is supported drifted from the document.
|
|
"""
|
|
doc = (INSTALL_SH.parent / "docs" / "DISTRO_COMPATIBILITY.md").read_text(encoding="utf-8")
|
|
experimental = doc[doc.index("## Experimental Support") : doc.index("## Not Supported")]
|
|
misfiled = [
|
|
line.split("|")[1].strip()
|
|
for line in experimental.splitlines()
|
|
if line.startswith("|") and "✅" in line
|
|
]
|
|
assert not misfiled, f"listed as supported but filed as experimental: {misfiled}"
|
|
|
|
def test_no_release_number_gate_survives_in_the_installer(self):
|
|
source = INSTALL_SH.read_text(encoding="utf-8")
|
|
assert "check_ubuntu_version" not in source
|
|
assert "requires Ubuntu" not in source, "the installer must not gate on a release label"
|
|
|
|
@staticmethod
|
|
def _check(interpreter: Path) -> str:
|
|
script = f"""
|
|
PYTHON_CMD="python3"
|
|
SYSTEM_PYTHON="{interpreter}"
|
|
{_source("python_version_of", "python_version_at_least", "python_has_gi",
|
|
"select_python_interpreter", "check_python_version")}
|
|
export PATH="{interpreter.parent}:/usr/bin:/bin"
|
|
check_python_version && echo "ACCEPTED" || echo "REJECTED"
|
|
"""
|
|
return _run(script).stdout
|
|
|
|
@pytest.mark.parametrize("distro_id,version_id", DERIVATIVES)
|
|
def test_a_derivative_with_a_new_enough_python_is_accepted(
|
|
self, tmp_path, distro_id, version_id
|
|
):
|
|
"""What the distro calls itself must not decide this; its Python must."""
|
|
interpreter = _fake_python(
|
|
tmp_path / f"{distro_id}-{version_id}" / "python3", "3.12", has_gi=True
|
|
)
|
|
assert "ACCEPTED" in self._check(interpreter)
|
|
|
|
def test_an_interpreter_below_the_floor_is_still_rejected(self, tmp_path):
|
|
"""Dropping the label gate must not drop the real one."""
|
|
interpreter = _fake_python(tmp_path / "jammy" / "python3", "3.10", has_gi=True)
|
|
assert "REJECTED" in self._check(interpreter)
|
|
|
|
def test_the_floor_itself_is_accepted(self, tmp_path):
|
|
interpreter = _fake_python(tmp_path / "floor" / "python3", "3.11", has_gi=True)
|
|
assert "ACCEPTED" in self._check(interpreter)
|
|
|
|
|
|
def test_installer_never_creates_venv_with_bare_python3():
|
|
source = INSTALL_SH.read_text(encoding="utf-8")
|
|
for line in source.splitlines():
|
|
stripped = line.strip()
|
|
if stripped.startswith("python3 -m venv") or stripped.startswith("python3 -m virtualenv"):
|
|
raise AssertionError(f"venv must be created via $PYTHON_CMD: {stripped}")
|