Files
Comfy-Org-ComfyUI-Manager/tests/test_git_exe_setting.py
Dr.Lt.Data 9117bce3e1 Fix git_exe, the commit and submodules of a node pack and the git steps of install and update
Three fixes. The CHANGELOG has an entry for each.

- Use the git executable set as git_exe
- Read the commit of a node pack whose refs are packed, and bring its
  submodules to the commit that is checked out
- Fail an update whose pull or submodule update failed, leave the node pack
  at its commit, remove what a clone that failed left, and refuse an install
  of a node pack that another install is working on
2026-11-18 00:10:04 +09:00

328 lines
13 KiB
Python

"""`git_exe` chooses the git executable that GitPython runs.
Each case runs a real function of the Manager with the real GitPython. The
configured executable is a script that records its arguments and then runs the
git of the test environment. `git_exe` is used only when the configuration file
is in a protected directory and the value is a working git.
"""
import ast
import configparser
import logging
import os
import shutil
import sys
from pathlib import Path
from types import SimpleNamespace
import git
import pytest
from manager_test_utils import GLOB_DIR, load_manager_util
from test_install_flags_config import GIT_LOCATION, _run_child
pytestmark = pytest.mark.skipif(os.name == "nt", reason="the executables of the cases are shell scripts")
ROOT = GLOB_DIR.parent
NOT_A_GIT = {
"a path that does not exist": None,
"a program that fails": "#!/bin/sh\nexit 3\n",
"a program that is not git": "#!/bin/sh\necho hello\n",
"a program that waits": "#!/bin/sh\nexec sleep 30\n",
"a program that prints bytes that are not text": "#!/bin/sh\nprintf '\\377\\376'\n",
"a file that cannot be run": "not a program\n",
}
def take(path, name, namespace):
"""Define the function of the file in the namespace and return it."""
function = [node for node in ast.parse(path.read_text(encoding="utf-8")).body
if isinstance(node, ast.FunctionDef) and node.name == name]
assert len(function) == 1
exec(compile(ast.Module(body=function, type_ignores=[]), str(path), "exec"), namespace)
return namespace[name]
@pytest.fixture
def manager_util(monkeypatch):
module = load_manager_util()
find = module.find_git_executable
monkeypatch.setattr(module, "find_git_executable", lambda git_exe: find(git_exe, timeout=2))
return module
@pytest.fixture(autouse=True)
def default_git(monkeypatch):
# a git that a case runs is to find its repository by the directory it is run in,
# and the git is the one that the case names, whatever the shell of the run names
for name in (*GIT_LOCATION, 'GIT_EXE_PATH', 'GIT_PYTHON_GIT_EXECUTABLE'):
monkeypatch.delenv(name, raising=False)
# GitPython keeps the git that the variable of the shell named when it last looked
git.refresh()
yield
# the variables a case set are removed before GitPython looks for its git again
monkeypatch.undo()
git.refresh()
@pytest.fixture
def recording_git(tmp_path):
"""A git executable that appends each command line to `calls`."""
calls = tmp_path / "calls"
executable = tmp_path / "recording-git"
executable.write_text(f'#!/bin/sh\necho "$@" >> "{calls}"\nexec "{shutil.which("git")}" "$@"\n')
executable.chmod(0o755)
return SimpleNamespace(path=str(executable),
calls=lambda: calls.read_text().splitlines() if calls.exists() else [],
forget=lambda: calls.unlink(missing_ok=True))
@pytest.fixture(params=NOT_A_GIT)
def not_a_git(request, tmp_path):
path = tmp_path / "not-a-git"
if NOT_A_GIT[request.param] is not None:
path.write_text(NOT_A_GIT[request.param])
path.chmod(0o755)
return str(path)
def setup_git_executable(manager_util, git_exe, protected=True):
"""Run `setup_git_executable` of `manager_core.py` with `git_exe` as the configured value."""
take(GLOB_DIR / "manager_core.py", "setup_git_executable", {
"git": git, "logging": logging, "manager_util": manager_util,
"manager_migration": SimpleNamespace(has_system_user_api=lambda: protected),
"get_config": lambda: {"git_exe": git_exe},
})()
def test_configured_git_is_run(manager_util, recording_git, tmp_path):
setup_git_executable(manager_util, recording_git.path)
recording_git.forget()
git.Repo.init(tmp_path / "repo")
assert any(line.startswith("init") for line in recording_git.calls())
assert (tmp_path / "repo" / ".git").is_dir()
def test_empty_setting_keeps_the_default_git(manager_util, recording_git, tmp_path, caplog):
default = git.Git.GIT_PYTHON_GIT_EXECUTABLE
with caplog.at_level(logging.WARNING):
setup_git_executable(manager_util, "")
assert caplog.text == ""
assert git.Git.GIT_PYTHON_GIT_EXECUTABLE == default
def test_setting_that_is_no_git_is_reported_and_the_default_kept(manager_util, not_a_git, tmp_path, caplog):
default = git.Git.GIT_PYTHON_GIT_EXECUTABLE
flags = git.remote.FetchInfo._flag_map.copy()
with caplog.at_level(logging.WARNING):
setup_git_executable(manager_util, not_a_git)
assert not_a_git in caplog.text
assert git.Git.GIT_PYTHON_GIT_EXECUTABLE == default and git.remote.FetchInfo._flag_map == flags
git.Repo.init(tmp_path / "repo")
assert (tmp_path / "repo" / ".git").is_dir()
def test_setting_of_an_unprotected_configuration_is_not_used(manager_util, recording_git, tmp_path, caplog):
with caplog.at_level(logging.WARNING):
setup_git_executable(manager_util, recording_git.path, protected=False)
git.Repo.init(tmp_path / "repo")
assert recording_git.calls() == []
assert "git_exe" in caplog.text
def test_git_is_chosen_before_the_first_git_command_of_the_server():
"""The module runs its start-up statements in the order of the file; the ComfyUI version is read with git."""
body = ast.parse((GLOB_DIR / "manager_server.py").read_text(encoding="utf-8")).body
calls = [ast.unparse(node.value.func) for node in body if isinstance(node, ast.Expr) and isinstance(node.value, ast.Call)]
steps = [call for call in calls if call in ("core.setup_git_executable", "print_comfyui_version")]
assert steps == ["core.setup_git_executable", "print_comfyui_version"]
def script_env_of(manager_util, git_exe):
return take(GLOB_DIR / "manager_core.py", "get_script_env", {
"os": os, "comfy_path": "/comfy", "manager_util": manager_util,
"manager_migration": SimpleNamespace(has_system_user_api=lambda: True),
"get_config": lambda: {"git_exe": git_exe}, "working_git_exe": {},
})
@pytest.mark.parametrize("protected", [True, False])
def test_scripts_are_given_the_git_of_a_protected_configuration(manager_util, recording_git, protected):
get_script_env = take(GLOB_DIR / "manager_core.py", "get_script_env", {
"os": os, "comfy_path": "/comfy", "manager_util": manager_util,
"manager_migration": SimpleNamespace(has_system_user_api=lambda: protected),
"get_config": lambda: {"git_exe": recording_git.path}, "working_git_exe": {},
})
assert get_script_env().get("GIT_EXE_PATH") == (recording_git.path if protected else None)
@pytest.mark.parametrize("git_exe", ["", None])
def test_scripts_are_given_no_git_without_the_setting(manager_util, git_exe):
get_script_env = script_env_of(manager_util, git_exe)
assert get_script_env().get("GIT_EXE_PATH") is None
def test_scripts_are_given_no_git_that_is_not_one(manager_util, not_a_git):
get_script_env = script_env_of(manager_util, not_a_git)
assert get_script_env().get("GIT_EXE_PATH") is None
def test_git_for_scripts_is_checked_once(manager_util, recording_git):
"""Every command of an install asks for the environment; the check starts a process."""
get_script_env = script_env_of(manager_util, recording_git.path)
assert [get_script_env().get("GIT_EXE_PATH") for _ in range(3)] == [recording_git.path] * 3
assert recording_git.calls() == ["version"]
def test_git_for_scripts_that_was_no_git_is_checked_again(manager_util, recording_git, tmp_path):
later = tmp_path / "installed-later"
get_script_env = script_env_of(manager_util, str(later))
assert get_script_env().get("GIT_EXE_PATH") is None
shutil.copy(recording_git.path, later)
assert get_script_env().get("GIT_EXE_PATH") == str(later)
def set_git_executable(manager_util, monkeypatch, git_exe, protected=True):
"""Run `set_git_executable` of `prestartup_script.py`; the variable GitPython reads when it is imported."""
# set and removed, so that the variable the function sets is removed after the case, also when there was none
monkeypatch.setenv("GIT_PYTHON_GIT_EXECUTABLE", "")
monkeypatch.delenv("GIT_PYTHON_GIT_EXECUTABLE")
config = configparser.ConfigParser(strict=False)
config.read_string("[default]\n" + ("" if git_exe is None else f"git_exe = {git_exe}\n"))
take(ROOT / "prestartup_script.py", "set_git_executable", {
"os": os, "manager_util": manager_util, "_has_system_user_api": protected, "default_conf": config["default"],
})()
return os.environ.get("GIT_PYTHON_GIT_EXECUTABLE")
def test_git_is_known_before_gitpython_is_imported(manager_util, monkeypatch, recording_git):
assert set_git_executable(manager_util, monkeypatch, recording_git.path) == recording_git.path
def test_case_that_set_the_variable_left_the_default_git():
"""Runs after the case above, which makes the function set the variable that GitPython reads."""
assert os.environ.get("GIT_PYTHON_GIT_EXECUTABLE") is None
assert git.Git.GIT_PYTHON_GIT_EXECUTABLE in ("git", shutil.which("git"))
def test_git_in_a_directory_with_a_percent_sign_is_known(manager_util, monkeypatch, recording_git, tmp_path):
"""A path of Windows may hold a `%`, which the parser takes as the start of a reference."""
(tmp_path / "100%").mkdir()
path = shutil.copy(recording_git.path, tmp_path / "100%" / "git")
assert set_git_executable(manager_util, monkeypatch, str(path)) == str(path)
def test_start_up_without_a_configuration_file_sets_nothing(manager_util, monkeypatch):
monkeypatch.setenv("GIT_PYTHON_GIT_EXECUTABLE", "")
monkeypatch.delenv("GIT_PYTHON_GIT_EXECUTABLE")
take(ROOT / "prestartup_script.py", "set_git_executable", {
"os": os, "manager_util": manager_util, "_has_system_user_api": True, "default_conf": {},
})()
assert os.environ.get("GIT_PYTHON_GIT_EXECUTABLE") is None
def test_setting_with_a_percent_sign_is_read_as_written_and_the_others_kept():
config = _run_child(r'''
write_ini("[default]\ngit_exe = %LOCALAPPDATA%\\Git\\bin\\git.exe\ndb_mode = local\nnetwork_mode = offline\n")
cfg = fresh_read()
print(json.dumps([cfg["git_exe"], cfg["db_mode"], cfg["network_mode"]]))
''')
assert config == ["%LOCALAPPDATA%\\Git\\bin\\git.exe", "local", "offline"]
@pytest.mark.parametrize("git_exe", ["", None])
def test_no_setting_leaves_the_environment_alone(manager_util, monkeypatch, git_exe):
assert set_git_executable(manager_util, monkeypatch, git_exe) is None
def test_setting_of_an_unprotected_configuration_is_not_put_in_the_environment(manager_util, monkeypatch, recording_git):
assert set_git_executable(manager_util, monkeypatch, recording_git.path, protected=False) is None
def test_setting_that_is_no_git_is_not_put_in_the_environment(manager_util, monkeypatch, not_a_git):
assert set_git_executable(manager_util, monkeypatch, not_a_git) is None
def helper_setup_environment(git_exe):
take(ROOT / "git_helper.py", "setup_environment", {"git": git, "sys": sys, "git_exe_path": git_exe})()
def test_helper_runs_the_git_it_is_given(recording_git, tmp_path):
helper_setup_environment(recording_git.path)
recording_git.forget()
git.Repo.init(tmp_path / "repo")
assert any(line.startswith("init") for line in recording_git.calls())
@pytest.mark.parametrize("git_exe", ["", None])
def test_helper_without_a_git_keeps_the_default(git_exe, capsys):
default = git.Git.GIT_PYTHON_GIT_EXECUTABLE
helper_setup_environment(git_exe)
assert capsys.readouterr().err == "" and git.Git.GIT_PYTHON_GIT_EXECUTABLE == default
@pytest.mark.parametrize("kind", [kind for kind in NOT_A_GIT if kind != "a program that waits"])
def test_helper_reports_what_is_no_git_and_keeps_the_default(kind, tmp_path, capsys):
default = git.Git.GIT_PYTHON_GIT_EXECUTABLE
path = tmp_path / "not-a-git"
if NOT_A_GIT[kind] is not None:
path.write_text(NOT_A_GIT[kind])
path.chmod(0o755)
helper_setup_environment(str(path))
assert str(path) in capsys.readouterr().err
assert git.Git.GIT_PYTHON_GIT_EXECUTABLE == default
git.Repo.init(tmp_path / "repo")
assert Path(tmp_path / "repo" / ".git").is_dir()
def test_git_named_by_a_command_on_path_is_run_by_its_full_path(manager_util, tmp_path, monkeypatch):
"""GitPython takes a name without a directory as a file of the current directory."""
monkeypatch.chdir(tmp_path)
setup_git_executable(manager_util, "git")
assert git.Git.GIT_PYTHON_GIT_EXECUTABLE == shutil.which("git")
git.Repo.init(tmp_path / "repo")
assert (tmp_path / "repo" / ".git").is_dir()
def test_scripts_and_gitpython_are_given_the_full_path_of_a_command_on_path(manager_util, monkeypatch):
get_script_env = script_env_of(manager_util, "git")
assert get_script_env().get("GIT_EXE_PATH") == shutil.which("git")
assert set_git_executable(manager_util, monkeypatch, "git") == shutil.which("git")
def test_setting_saved_beside_a_git_exe_with_a_percent_sign_keeps_it():
saved = _run_child(r'''
write_ini("[default]\ngit_exe = %LOCALAPPDATA%\\Git\\bin\\git.exe\ndb_mode = local\n")
cfg = fresh_read()
cfg["db_mode"] = "remote"
manager_core.write_config()
print(json.dumps(sorted(line for line in open(CONFIG_PATH).read().splitlines() if line.startswith(("git_exe", "db_mode")))))
''')
assert saved == ["db_mode = remote", "git_exe = %LOCALAPPDATA%\\Git\\bin\\git.exe"]