Files
Comfy-Org-ComfyUI-Manager/tests/test_git_failures.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

389 lines
18 KiB
Python

"""An update or an install whose git step fails is a failure, and can be done again.
The cases run git on repositories of a temporary directory, in the isolated child of
tests/test_install_flags_config.py. The node pack has a submodule, and the repository of
the submodule is moved away to make the step fail after the node pack itself was pulled
or cloned.
"""
import os
import pytest
from test_install_flags_config import _CHILD_PREAMBLE, REPO_ROOT, _run_child
PRELUDE = '''
import asyncio, os, pathlib, subprocess
from unittest.mock import AsyncMock, Mock
core = manager_core
tmp = pathlib.Path(tmp)
# the git that the Manager runs is to clone a submodule from a directory
os.environ.update(GIT_CONFIG_COUNT='1', GIT_CONFIG_KEY_0='protocol.file.allow', GIT_CONFIG_VALUE_0='always')
# the git helper looks for this file where ComfyUI is said to be
(tmp / 'folder_paths.py').touch()
os.environ['COMFYUI_PATH'] = str(tmp)
nodes = tmp / 'custom_nodes'
nodes.mkdir()
core.get_default_custom_nodes_path = lambda: str(nodes)
core.get_custom_nodes_paths = lambda: [str(nodes)]
core.is_valid_url = lambda url: True
manager = core.UnifiedManager()
manager.reload = AsyncMock()
manager.get_custom_nodes = AsyncMock(return_value={})
manager.get_cnr_by_repo = Mock(return_value=None)
manager.execute_install_script = Mock(return_value=True)
core.unified_manager = manager
core.execute_install_script = Mock(return_value=True)
def packs():
# the files of the claims of installs are in `.disabled`
return [name for name in os.listdir(nodes) if name != '.disabled']
def git(path, *args):
subprocess.run(['git', '-c', 'user.name=test', '-c', 'user.email=test@example.invalid', *args], cwd=path, check=True, capture_output=True)
def head(path):
return subprocess.run(['git', 'rev-parse', 'HEAD'], cwd=path, check=True, capture_output=True, text=True).stdout.strip()
def failed(call, *args, **options):
try:
call(*args, **options)
except Exception:
return True
return False
# `origin` has the submodules `asset` and `library`; its two commits name the two commits of each.
# `pack` is a clone made at the first commit: it is one commit behind, and so are its submodules.
# The repository of `library` is away: `asset` is updated before the update fails.
asset, library, origin, pack = tmp / 'asset', tmp / 'library', tmp / 'origin', tmp / 'pack'
for repository in (asset, library, origin):
repository.mkdir()
git(repository, 'init', '-q')
commits = []
for version in (1, 2):
for submodule in (asset, library):
(submodule / '__init__.py').write_text('VERSION = %d' % version)
git(submodule, 'add', '.')
git(submodule, 'commit', '-q', '-m', 'version %d' % version)
if version == 1:
git(origin, 'submodule', 'add', '-q', str(submodule), submodule.name)
else:
git(origin / submodule.name, 'pull', '-q')
git(origin, 'commit', '-q', '-a', '-m', 'library %d' % version)
commits.append(head(origin))
if version == 1:
git(tmp, 'clone', '-q', '--recursive', str(origin), 'pack')
away = tmp / 'library.away'
library.rename(away)
'''
# a pull that failed, the commit after it, and the pull done again with the repository of the submodule back
PULL_TWICE = '''
first = failed(core.git_pull, str(pack))
after_first = head(pack) == commits[0]
asset_after_first = (pack / 'asset/__init__.py').read_text()
away.rename(library)
second = failed(core.git_pull, str(pack))
print(json.dumps({'first failed': first, 'at its commit': after_first, 'asset at its commit': asset_after_first, 'second failed': second,
'updated': head(pack) == commits[1], 'library': (pack / 'library/__init__.py').read_text()}))
'''
# `asset`, which was updated before the update failed, is back at the commit that the pack names
PULLED = {'first failed': True, 'at its commit': True, 'asset at its commit': 'VERSION = 1', 'second failed': False, 'updated': True, 'library': 'VERSION = 2'}
def run(body):
return _run_child(PRELUDE + body)
def test_pull_that_fails_at_the_submodules_leaves_the_pack_at_its_commit():
"""At the new commit the next update finds nothing to do, and the install script of the update is never run."""
assert run(PULL_TWICE) == PULLED
def test_pull_of_the_git_helper_that_fails_is_a_failure():
"""On Windows the pull runs in the git helper, which ends with 0 and says in its output that it failed."""
assert run("core.platform.system = lambda: 'Windows'\n" + PULL_TWICE) == PULLED
# `library` is not cloned, so that the fetch of the git helper passes it and the update of the submodules is what fails
LIBRARY_NOT_CLONED = '''
git(pack, 'submodule', 'deinit', '-q', '-f', 'library')
# moved, as git makes files read-only that Windows does not remove
(pack / '.git/modules/library').rename(tmp / 'library.modules')
'''
def test_pull_of_the_git_helper_that_fails_at_the_submodules_puts_them_back():
"""The next commit of `asset` has a submodule of its own, whose repository is away: `asset` is checked out before that one fails."""
data = run('''
away.rename(library)
nested = tmp / 'nested'
nested.mkdir()
git(nested, 'init', '-q')
git(nested, 'commit', '-q', '--allow-empty', '-m', 'nested')
git(asset, 'submodule', 'add', '-q', str(nested), 'nested')
git(asset, 'commit', '-q', '-m', 'a submodule')
git(origin / 'asset', 'pull', '-q')
git(origin, 'commit', '-q', '-a', '-m', 'asset with a submodule')
nested.rename(tmp / 'nested.away')
core.platform.system = lambda: 'Windows'
first = failed(core.git_pull, str(pack))
print(json.dumps({'failed': first, 'at its commit': head(pack) == commits[0], 'asset at its commit': not (pack / 'asset/.gitmodules').exists()}))
''')
assert data == {'failed': True, 'at its commit': True, 'asset at its commit': True}
@pytest.mark.parametrize('where', ['', "core.platform.system = lambda: 'Windows'\n"], ids=['in the server process', 'in the git helper'])
def test_pull_that_fails_leaves_a_pack_that_was_not_on_its_branch_as_it_was(where):
"""The pack is at an older commit than its branch, which has a commit of its own: both are where they were."""
data = run('''
away.rename(library)
branch = subprocess.run(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], cwd=pack, check=True, capture_output=True, text=True).stdout.strip()
git(pack, 'pull', '-q')
git(pack, 'commit', '-q', '--allow-empty', '-m', 'a commit of the pack alone')
tip = head(pack)
git(pack, 'checkout', '-q', '--detach', commits[0])
library.rename(away)
''' + LIBRARY_NOT_CLONED + where + '''
first = failed(core.git_pull, str(pack))
print(json.dumps({'failed': first, 'branch at its commit': subprocess.run(['git', 'rev-parse', branch], cwd=pack, check=True, capture_output=True, text=True).stdout.strip() == tip,
'pack at its commit': head(pack) == commits[0], 'asset': (pack / 'asset/__init__.py').read_text()}))
''')
assert data == {'failed': True, 'branch at its commit': True, 'pack at its commit': True, 'asset': 'VERSION = 1'}
def test_install_that_fails_at_the_submodules_leaves_no_directory():
"""What is left of the clone is in the way of the next install."""
data = run('''
path = tmp / 'installed'
first = manager.repo_install(str(origin), str(path), instant_execution=True).result
left = path.exists()
away.rename(library)
second = manager.repo_install(str(origin), str(path), instant_execution=True).result
print(json.dumps({'first': first, 'left': left, 'second': second, 'library': (path / 'library/__init__.py').read_text()}))
''')
assert data == {'first': False, 'left': False, 'second': True, 'library': 'VERSION = 2'}
def test_install_by_url_that_fails_at_the_submodules_leaves_no_directory():
data = run('''
result = asyncio.run(core.gitclone_install(str(origin), instant_execution=True)).result
print(json.dumps({'result': result, 'left': packs(), 'install scripts': core.execute_install_script.call_count}))
''')
assert data == {'result': False, 'left': [], 'install scripts': 0}
# the runner of the server returns the exit code of the git helper, and the default one, which cm-cli has, raises for it
RUNNER_FAILURES = ['return 1', 'raise subprocess.CalledProcessError(1, command)']
# Windows, as far as these cases go: the clone runs in the git helper, and a read-only file is not removed.
# The helper is replaced by one that fails after it made the directory, with a read-only file in it as git leaves its pack files.
WINDOWS = '''
import stat
unlink = os.unlink
def unlink_a_file_that_may_be_written(path, *, dir_fd=None):
if not os.stat(path, dir_fd=dir_fd, follow_symlinks=False).st_mode & stat.S_IWRITE:
raise PermissionError(13, 'Access is denied', str(path))
unlink(path, dir_fd=dir_fd)
def clone_that_fails(command, cwd):
os.makedirs(command[-1], exist_ok=True)
(pathlib.Path(command[-1]) / 'pack').touch(stat.S_IREAD)
FAILURE
os.unlink = unlink_a_file_that_may_be_written
core.platform.system = lambda: 'Windows'
core.manager_funcs.run_script = clone_that_fails
'''
@pytest.mark.parametrize('failure', RUNNER_FAILURES)
def test_install_whose_clone_in_the_git_helper_fails_leaves_no_directory(failure):
data = run((WINDOWS + '''
result = manager.repo_install('https://github.com/owner/fixture', str(tmp / 'fixture')).result
print(json.dumps({'result': result, 'left': (tmp / 'fixture').exists()}))
''').replace('FAILURE', failure))
assert data == {'result': False, 'left': False}
@pytest.mark.parametrize('failure', RUNNER_FAILURES)
def test_install_whose_clone_fails_leaves_a_directory_that_was_there(failure):
data = run((WINDOWS + '''
(tmp / 'fixture').mkdir()
(tmp / 'fixture/kept').write_text('a file that was there')
result = manager.repo_install('https://github.com/owner/fixture', str(tmp / 'fixture')).result
print(json.dumps({'result': result, 'kept': (tmp / 'fixture/kept').read_text()}))
''').replace('FAILURE', failure))
assert data == {'result': False, 'kept': 'a file that was there'}
@pytest.mark.parametrize('failure', RUNNER_FAILURES)
def test_install_by_url_whose_clone_in_the_git_helper_fails_leaves_no_directory(failure):
data = run((WINDOWS + '''
result = asyncio.run(core.gitclone_install('https://github.com/owner/fixture')).result
print(json.dumps({'result': result, 'left': packs()}))
''').replace('FAILURE', failure))
assert data == {'result': False, 'left': []}
# A check that saw no directory is no proof that this install made it: another install can make it before the clone starts.
MADE_BY_ANOTHER_INSTALL = '''
exists = os.path.exists
DESTINATION.mkdir(parents=True)
(DESTINATION / 'kept').write_text('of another install')
os.path.exists = lambda path: False if str(path) == str(DESTINATION) else exists(path)
'''
@pytest.mark.parametrize('failure', RUNNER_FAILURES)
def test_install_whose_clone_fails_leaves_a_directory_that_another_install_made(failure):
data = run((WINDOWS + MADE_BY_ANOTHER_INSTALL.replace('DESTINATION', "(tmp / 'fixture')") + '''
result = manager.repo_install('https://github.com/owner/fixture', str(tmp / 'fixture')).result
print(json.dumps({'result': result, 'kept': (tmp / 'fixture/kept').is_file()}))
''').replace('FAILURE', failure))
assert data == {'result': False, 'kept': True}
@pytest.mark.parametrize('failure', RUNNER_FAILURES)
def test_install_by_url_whose_clone_fails_leaves_a_directory_that_another_install_made(failure):
data = run((WINDOWS + MADE_BY_ANOTHER_INSTALL.replace('DESTINATION', "(nodes / 'fixture')") + '''
result = asyncio.run(core.gitclone_install('https://github.com/owner/fixture')).result
print(json.dumps({'result': result, 'kept': (nodes / 'fixture/kept').is_file()}))
''').replace('FAILURE', failure))
assert data == {'result': False, 'kept': True}
@pytest.mark.skipif(os.name != 'posix' or os.geteuid() == 0, reason='the folder can be removed here')
def test_what_a_failed_clone_left_and_cannot_be_removed_is_reported():
"""As a file that another program has open on Windows: here a file in a folder that may not be written."""
data = run('''
import logging
messages = []
class Messages(logging.Handler):
def emit(self, record):
messages.append(record.getMessage())
def clone_that_fails(command, cwd):
held = pathlib.Path(command[-1]) / 'held'
held.mkdir(parents=True, exist_ok=True)
(held / 'file').touch()
held.chmod(0o555)
return 1
logging.getLogger().addHandler(Messages())
core.platform.system = lambda: 'Windows'
core.manager_funcs.run_script = clone_that_fails
result = manager.repo_install('https://github.com/owner/fixture', str(tmp / 'fixture')).result
(tmp / 'fixture/held').chmod(0o755)
print(json.dumps({'result': result, 'reported': [message for message in messages if str(tmp / 'fixture') in message] != []}))
''')
assert data == {'result': False, 'reported': True}
@pytest.mark.parametrize('failure', RUNNER_FAILURES)
def test_file_whose_mode_cannot_be_changed_does_not_hide_the_failed_clone(failure):
"""What is left is removed as far as it can be, and the install ends as one whose clone failed."""
data = run((WINDOWS + '''
def chmod(path, mode, **options):
raise PermissionError(13, 'Access is denied', str(path))
os.chmod = chmod
result = manager.repo_install('https://github.com/owner/fixture', str(tmp / 'fixture'))
print(json.dumps({'result': result.result, 'message': result.msg}))
''').replace('FAILURE', failure))
assert data == {'result': False, 'message': 'Failed to clone repo: https://github.com/owner/fixture'}
# Two installs of one node pack at a time. The clone runs in the git helper, which is replaced by one that leaves a file.
TWO_INSTALLS = """
URL = 'https://github.com/owner/fixture'
fixture = nodes / 'fixture'
def cloned(command, cwd):
os.makedirs(command[-1], exist_ok=True)
(pathlib.Path(command[-1]) / 'cloned').touch()
return 0
core.platform.system = lambda: 'Windows'
core.manager_funcs.run_script = cloned
"""
@pytest.mark.parametrize('first', ['manager.repo_install(URL, str(fixture))', 'asyncio.run(core.gitclone_install(URL))'], ids=['queued', 'by url'])
def test_install_of_a_node_pack_that_is_being_installed_is_refused(first):
"""Its clone would go into the directory that the first install has made, and be removed with it when the clone of the first fails."""
data = run(TWO_INSTALLS + """
others = []
def clone_with_another_install_in_it(command, cwd):
core.manager_funcs.run_script = cloned
others.append(manager.repo_install(URL, str(fixture)).result)
return 1
core.manager_funcs.run_script = clone_with_another_install_in_it
first = FIRST.result
left = packs()
again = manager.repo_install(URL, str(fixture)).result
print(json.dumps({'first': first, 'other': others, 'left': left, 'again': again, 'cloned': (fixture / 'cloned').exists()}))
""".replace('FIRST', first))
assert data == {'first': False, 'other': [False], 'left': [], 'again': True, 'cloned': True}
# another process, as `cm-cli` beside the server: it has the install of the node pack for itself until it is told to go on, or killed
OTHER_PROCESS = _CHILD_PREAMBLE.format(glob_path=str(REPO_ROOT / 'glob')) + """
with manager_core.claimed_install(sys.argv[1]) as claimed:
print(json.dumps(claimed), flush=True)
sys.stdin.read(1)
"""
def test_install_of_a_node_pack_that_another_process_installs_is_refused_until_that_process_is_gone():
"""The process is killed, as a container that is stopped in the middle of a clone: what it had is free, whatever file it left."""
data = run(TWO_INSTALLS + """
other = subprocess.Popen([sys.executable, '-c', OTHER_PROCESS, str(fixture)], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
claimed = json.loads(other.stdout.readline())
while_it_runs = manager.repo_install(URL, str(fixture))
left = packs()
other.kill()
other.wait()
after_it = manager.repo_install(URL, str(fixture))
print(json.dumps({'claimed by the other': claimed, 'while it runs': while_it_runs.result, 'left': left,
'after it': after_it.result, 'cloned': (fixture / 'cloned').exists()}))
""".replace('OTHER_PROCESS', repr(OTHER_PROCESS)))
assert data == {'claimed by the other': True, 'while it runs': False, 'left': [], 'after it': True, 'cloned': True}
def test_claim_of_an_install_is_a_file_beside_the_node_packs():
"""In `.disabled/.locks`, which ComfyUI does not load: where that cannot be written, nothing can be installed either.
The Manager takes the folders in `.disabled` for node packs that are disabled, and not this one."""
data = run(TWO_INSTALLS + """
result = manager.repo_install(URL, str(fixture)).result
sys.modules['folder_paths'].get_folder_paths = lambda kind: [str(nodes)]
core.cnr_utils.get_cnr_data = AsyncMock(return_value=[])
found = core.UnifiedManager()
asyncio.run(found.reload('cache'))
print(json.dumps({'result': result, 'in custom_nodes': sorted(os.listdir(nodes)), 'in .disabled': os.listdir(nodes / '.disabled'),
'in .locks': os.listdir(nodes / '.disabled/.locks'), 'enabled': sorted(found.unknown_active_nodes),
'disabled': sorted(found.unknown_inactive_nodes), 'node packs': core.get_installed_node_packs()}))
""")
assert data == {'result': True, 'in custom_nodes': ['.disabled', 'fixture'], 'in .disabled': ['.locks'], 'in .locks': ['fixture.lock'],
'enabled': ['fixture'], 'disabled': [], 'node packs': {}}
def test_install_whose_claim_cannot_be_taken_fails():
"""Without the claim, what it removes after a clone that failed can be the clone of another install."""
data = run(TWO_INSTALLS + """
clones = []
core.manager_funcs.run_script = lambda command, cwd: clones.append(command) or 0
# no file can be made in it
(nodes / '.disabled').touch()
by_url = asyncio.run(core.gitclone_install(URL)).result
queued = manager.repo_install(URL, str(fixture)).result
print(json.dumps({'queued': queued, 'by url': by_url, 'clones': clones, 'in custom_nodes': os.listdir(nodes)}))
""")
assert data == {'queued': False, 'by url': False, 'clones': [], 'in custom_nodes': ['.disabled']}