mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-19 21:37:12 +03:00
a1bbd329ea
utils.py held three subjects in one 871-line file. It is now a package with one module per subject: utils/files.py (atomic writes, temp files, file mode and owner, signatures and digests, JSON and YAML file helpers), utils/urls.py (the base_url helpers) and utils/env.py (truthy values, env numbers, proxy env helpers). utils/__init__.py re-exports every public name, so no importer changes. Function bodies are unchanged, no function-level import moved, and the logger keeps the name "utils". Tests patch a name in the module that now defines it. Patches stay on the package where production reads the name through a function-level "from utils import". The tests of utils itself move to tests/utils/. A root module that becomes a folder drops out of anything that copies root *.py files plus a fixed list of packages, so the fixtures that build a partial source tree now list utils, as do pyproject's packages.find, three check scripts and the CI change classifier.
256 lines
11 KiB
Python
256 lines
11 KiB
Python
"""Bash activation crosses real setup, PM install, and uv dependency publication.
|
|
|
|
Only the downloaded tool payloads are fixtures: bootstrap uv locates the test
|
|
interpreter, then delegates every dependency operation to real, offline uv.
|
|
The real PM stage builder seeds its locked dependencies online before activation.
|
|
PM/activation/setup code is copied unmodified; all state is disposable.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import shlex
|
|
import shutil
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
from pm.lock import Lockfile
|
|
from pm.store import current_target
|
|
from tests.pm._fixtures import _wheel, make_tar, served
|
|
|
|
|
|
pytestmark = pytest.mark.platforms("posix")
|
|
REPO = Path(__file__).resolve().parents[2]
|
|
|
|
|
|
def _snapshot(paths):
|
|
"""Notice creation, rewriting, chmod, and new children in protected locations."""
|
|
result = {}
|
|
for root in paths:
|
|
for path in [root, *sorted(root.rglob("*"))]:
|
|
if path.exists():
|
|
info = path.stat()
|
|
result[str(path)] = (
|
|
stat.S_IMODE(info.st_mode), info.st_mtime_ns,
|
|
path.read_bytes() if path.is_file() else None,
|
|
)
|
|
return result
|
|
|
|
|
|
def test_activation_real_setup_pm_lifecycle(tmp_path, served):
|
|
bash, uv = shutil.which("bash"), shutil.which("uv")
|
|
assert bash and uv, "this integration contract requires Bash and real uv"
|
|
interpreter = str(Path(sys._base_executable).resolve())
|
|
core = tmp_path / "checkout with spaces"
|
|
core.mkdir()
|
|
home = tmp_path / "home"
|
|
home.mkdir()
|
|
hermes_home = home / ".hermes"
|
|
runtime = tmp_path / "runtime"
|
|
scratch = tmp_path / "tmp"
|
|
scratch.mkdir()
|
|
env = {
|
|
"PATH": os.environ["PATH"], "HOME": str(home), "HERMES_HOME": str(hermes_home),
|
|
"HERMES_RUNTIME_DIR": str(runtime), "SHELL": bash, "TMPDIR": str(scratch),
|
|
"XDG_CONFIG_HOME": str(home / ".config"), "XDG_CACHE_HOME": str(home / ".cache"),
|
|
"LANG": "C.UTF-8", "PYTHONNOUSERSITE": "1", "UV_OFFLINE": "1",
|
|
"UV_CACHE_DIR": str(home / ".cache" / "uv"), "UV_PYTHON_DOWNLOADS": "never",
|
|
}
|
|
for name in ("activate", "setup-hermes.sh", "hermes_constants.py", "hermes_yaml.py",
|
|
"scripts/_activation.sh"):
|
|
(core / name).parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy2(REPO / name, core / name)
|
|
for name in ("pm", "hermes_cli", "utils"):
|
|
shutil.copytree(REPO / name, core / name, ignore=shutil.ignore_patterns("__pycache__"))
|
|
# Plugin selection imports the real CLI config reader even with no plugins.
|
|
# Supply its installed YAML dependency, not a stub parser or config module.
|
|
import ruamel.yaml
|
|
shutil.copytree(Path(ruamel.yaml.__file__).parent, core / "ruamel" / "yaml", ignore=shutil.ignore_patterns("__pycache__"))
|
|
|
|
# Never copy real user files: these are deliberately public fixture sentinels.
|
|
protected = [core / ".env", home / ".local" / "bin", hermes_home / "skills",
|
|
home / ".bashrc", home / ".bash_profile", home / ".zshrc"]
|
|
for path in (home / ".local" / "bin" / "hermes", hermes_home / "skills" / "keep.md",
|
|
home / ".bashrc", home / ".bash_profile", home / ".zshrc"):
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text("user-owned fixture\n", encoding="utf-8")
|
|
(hermes_home / "skills").chmod(0o755)
|
|
(core / ".env.example").write_text("FIXTURE_ONLY=example\n", encoding="utf-8")
|
|
(core / "skills").mkdir()
|
|
(core / "skills" / "bundled.md").write_text("must not be seeded\n", encoding="utf-8")
|
|
untouched = _snapshot(protected)
|
|
|
|
wheels = tmp_path / "wheels"
|
|
wheels.mkdir()
|
|
_wheel(wheels, "activation_dep", "1.0")
|
|
_wheel(wheels, "dev_fixture", "1.0")
|
|
_wheel(wheels, "test_fixture", "1.0")
|
|
(core / "pyproject.toml").write_text(
|
|
'[project]\nname="activation-proof"\nversion="1"\nrequires-python=">=3.11"\n'
|
|
'dependencies=["activation-dep==1.0"]\n[project.optional-dependencies]\nall=[]\n'
|
|
'[dependency-groups]\ndev=["dev-fixture==1.0"]\ntest=["test-fixture==1.0"]\n'
|
|
'[tool.uv]\npackage=false\nno-index=true\ndefault-groups=[]\n'
|
|
f'find-links=[{json.dumps(wheels.as_posix())}]\n', encoding="utf-8",
|
|
)
|
|
locked = subprocess.run(
|
|
[uv, "lock", "--offline", "--python", interpreter], cwd=core, env=env,
|
|
capture_output=True, text=True, timeout=60,
|
|
check=False,
|
|
)
|
|
assert locked.returncode == 0, locked.stdout + locked.stderr
|
|
dependency_lock = (core / "uv.lock").read_bytes()
|
|
|
|
# Seed PM's own cache with its real locked wheels, not the application's
|
|
# fixture wheel or a copied host cache. Discard this environment so source
|
|
# still bootstraps and publishes the isolated PM runtime itself, offline.
|
|
seed = tmp_path / "pm-seed"
|
|
seed_env = {key: value for key, value in env.items() if key != "UV_OFFLINE"}
|
|
for key in ("SSL_CERT_FILE", "SSL_CERT_DIR", "NIX_SSL_CERT_FILE"):
|
|
if key in os.environ:
|
|
seed_env[key] = os.environ[key]
|
|
seeded = subprocess.run(
|
|
[interpreter, "-I", "-B", "-c",
|
|
"import sys; from pathlib import Path; sys.path.insert(0, sys.argv[1]); "
|
|
"from pm.runtime_stage import stage_runtime; "
|
|
"stage_runtime(Path(sys.argv[2]), Path(sys.argv[3]), Path(sys.argv[4]), "
|
|
"project=Path(sys.argv[1]) / 'pm', offline=False)",
|
|
str(core), uv, interpreter, str(seed)],
|
|
cwd=tmp_path, env=seed_env, capture_output=True, text=True, timeout=180,
|
|
check=False,
|
|
)
|
|
assert seeded.returncode == 0, seeded.stdout + seeded.stderr
|
|
shutil.rmtree(seed)
|
|
assert not (hermes_home / "installs").exists()
|
|
|
|
docroot, base_url = served
|
|
# Both the shell bootstrap and PM's fallback downloader stay on loopback.
|
|
(core / "pm" / "artifact-mirror.json").write_text(
|
|
json.dumps({"origin": base_url, "prefix": "mirror/"}, indent=2) + "\n",
|
|
encoding="utf-8",
|
|
)
|
|
calls = tmp_path / "uv-calls"
|
|
uv_script = (
|
|
f"#!{bash}\n"
|
|
f"printf '%s\\n' \"$*\" >> {shlex.quote(str(calls))}\n"
|
|
'if [ "$1 $2" = "python install" ]; then exit 0; fi\n'
|
|
f'if [ "$1 $2" = "python find" ]; then printf \'%s\\n\' {shlex.quote(interpreter)}; exit 0; fi\n'
|
|
f"exec {shlex.quote(uv)} --offline \"$@\"\n"
|
|
)
|
|
_, uv_digest = make_tar(docroot, "uv.tar.gz", {"uv-fixture/uv": uv_script})
|
|
python_script = f'#!{bash}\nexec {shlex.quote(interpreter)} "$@"\n'
|
|
lock = Lockfile(core / "pm" / "lock.json")
|
|
# Replace shipped pins, not PM implementations or its package registry.
|
|
lock.path.unlink()
|
|
lock = Lockfile(lock.path)
|
|
target = current_target()
|
|
version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}+fixture"
|
|
|
|
def pin_python(revision):
|
|
filename = f"python-{revision}.tar.gz"
|
|
_, digest = make_tar(docroot, filename, {
|
|
"python/bin/python3": python_script,
|
|
"python/revision": revision,
|
|
})
|
|
lock.set_pin("python", version, {target: {"url": f"{base_url}/{filename}", "sha256": digest}})
|
|
lock.save()
|
|
return digest
|
|
|
|
lock.set_pin("uv", "fixture", {target: {"url": f"{base_url}/uv.tar.gz", "sha256": uv_digest}})
|
|
first_digest = pin_python("first")
|
|
|
|
def activate(*, succeeds=True):
|
|
# No `set -e`: inspect source's status and prove the caller survives.
|
|
script = '''
|
|
prior_path=$PATH
|
|
prior_pythonpath=${PYTHONPATH-}
|
|
source "$1/activate" --test-extras=all
|
|
status=$?
|
|
if [ "$status" != 0 ]; then
|
|
test "$PATH" = "$prior_path" || exit 91
|
|
test "${PYTHONPATH-}" = "$prior_pythonpath" || exit 92
|
|
test -z "${__HERMES_ACTIVATED-}" || exit 93
|
|
printf 'CALLER_SURVIVED:%s\\n' "$status"
|
|
exit "$status"
|
|
fi
|
|
python3 -c 'import activation_dep, json, os; print(json.dumps({"version": activation_dep.__version__, "module": activation_dep.__file__, "pythonpath": os.environ["PYTHONPATH"]}))' || exit 94
|
|
"$__HERMES_TEST_PYTHON" -c 'import dev_fixture, test_fixture' || exit 97
|
|
python3 -c 'import importlib.util; assert importlib.util.find_spec("dev_fixture") is None' || exit 98
|
|
deactivate
|
|
test "$PATH" = "$prior_path" || exit 95
|
|
test "${PYTHONPATH-}" = "$prior_pythonpath" || exit 96
|
|
'''
|
|
result = subprocess.run(
|
|
[bash, "--noprofile", "--norc", "-c", script, "activation-test", str(core)],
|
|
cwd=tmp_path, env=env, capture_output=True, text=True, timeout=90,
|
|
check=False,
|
|
)
|
|
assert _snapshot(protected) == untouched, result.stdout + result.stderr
|
|
assert (result.returncode == 0) is succeeds, result.stdout + result.stderr
|
|
return result
|
|
|
|
def selection():
|
|
records = list(hermes_home.glob("installs/*/facts.json"))
|
|
assert len(records) == 1
|
|
return json.loads(records[0].read_text())["packages"]["venv"]
|
|
|
|
def operations(name):
|
|
return [line for line in calls.read_text().splitlines() if line.split()[0] == name]
|
|
|
|
def app_syncs():
|
|
return [line for line in operations("sync")
|
|
if "--frozen --all-packages" in line and "--group dev" not in line]
|
|
|
|
cold = activate()
|
|
first = selection()
|
|
probe = json.loads(cold.stdout)
|
|
assert probe["version"] == "1.0"
|
|
assert Path(probe["module"]).is_relative_to(Path(first["environment"]))
|
|
assert probe["pythonpath"].split(os.pathsep)[0] == str(core)
|
|
# Cold activation builds both PM's isolated runtime and the app environment.
|
|
assert "Preparing the isolated Hermes runtime" in cold.stderr
|
|
assert len(app_syncs()) == 1
|
|
facts = json.loads((runtime / "facts.json").read_text())["packages"]
|
|
assert facts["python"]["artifacts"] == [first_digest]
|
|
assert facts["uv"]["artifacts"] == [uv_digest]
|
|
|
|
# Also catch chmod of an existing .env, not just unwanted first creation.
|
|
(core / ".env").write_text("FIXTURE_ONLY=existing\n", encoding="utf-8")
|
|
(core / ".env").chmod(0o644)
|
|
untouched = _snapshot(protected)
|
|
activate()
|
|
assert selection() == first
|
|
# The first warm launch rebinds PM from bootstrap Python to its managed
|
|
# interpreter. The application selection is unchanged; later launches reuse both.
|
|
assert len(app_syncs()) == 1
|
|
prepared = operations("sync")
|
|
activate()
|
|
assert selection() == first
|
|
assert operations("sync") == prepared
|
|
assert len([line for line in operations("python") if line.startswith("python install ")]) == 3
|
|
|
|
second_digest = pin_python("second")
|
|
activate()
|
|
second = selection()
|
|
assert second["stamp"] != first["stamp"]
|
|
assert second["environment"] != first["environment"]
|
|
assert Path(first["environment"]).is_dir()
|
|
assert len(app_syncs()) == 2
|
|
facts = json.loads((runtime / "facts.json").read_text())["packages"]
|
|
assert facts["python"]["artifacts"] == [second_digest]
|
|
assert (core / "uv.lock").read_bytes() == dependency_lock
|
|
|
|
# A real uv failure must cross PM -> setup -> source without selection or
|
|
# caller mutation. An invalid local lock fails deterministically offline.
|
|
(core / "uv.lock").write_text("not valid TOML [\n", encoding="utf-8")
|
|
failed = activate(succeeds=False)
|
|
assert "pm install failed" in failed.stderr
|
|
assert "setup failed" in failed.stderr
|
|
assert "CALLER_SURVIVED:" in failed.stdout
|
|
assert selection() == second
|
|
assert len(app_syncs()) == 3
|
|
assert len([line for line in operations("python") if line.startswith("python install ")]) == 5
|