b3nw
9bb1dc8573
The update-check payload now carries a `dirty: bool` reflecting the working-tree state vs HEAD, computed via the same `git diff-index --quiet HEAD --` primitive already used by `_dirty_suffix()`. A dirty install at-or-past the latest release tag used to silently report "Up to date" with no remediation affordance; the Settings panel can now read this flag to offer `apply_force_update` (which already does `git checkout .` + `git reset --hard` to reset to a clean latest). The probe is conservatively clean on real errors (timeout, missing git, fatal) so a transient probe failure never produces a false- positive "local changes" alert. Closes #4085
356 lines
15 KiB
Python
356 lines
15 KiB
Python
"""
|
|
Tests for api/updates.py -- specifically the diagnostic code paths added
|
|
in fix/223-update-pull-failed-diagnostics (PR #227).
|
|
|
|
Tests cover the four new branches in _apply_update_inner():
|
|
1. fetch fails → network error message
|
|
2. pull fails + diverged history → recovery command with git reset --hard
|
|
3. pull fails + no upstream tracking → recovery command with set-upstream-to
|
|
4. pull fails + generic fallback → raw git output truncated at 300 chars
|
|
"""
|
|
from pathlib import Path
|
|
from unittest.mock import patch, call
|
|
import subprocess
|
|
|
|
import pytest
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _make_run_git_side_effect(*sequence):
|
|
"""Return a side_effect function that yields successive (stdout, ok) tuples."""
|
|
it = iter(sequence)
|
|
def _side_effect(args, cwd, timeout=10):
|
|
return next(it)
|
|
return _side_effect
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Path used for patching
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_MODULE = 'api.updates'
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests for _apply_update_inner() diagnostic paths
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestApplyUpdateDiagnostics:
|
|
"""New code paths introduced in PR #227."""
|
|
|
|
def _apply(self, target, run_git_side_effect):
|
|
"""Call _apply_update_inner with _apply_lock bypassed and _run_git mocked."""
|
|
from api import updates
|
|
with patch(f'{_MODULE}._run_git', side_effect=run_git_side_effect), \
|
|
patch.object(updates, '_apply_lock') as mock_lock:
|
|
mock_lock.acquire.return_value = True
|
|
mock_lock.release.return_value = None
|
|
return updates._apply_update_inner(target)
|
|
|
|
# ------------------------------------------------------------------
|
|
# Path 1: fetch step fails → network error message
|
|
# ------------------------------------------------------------------
|
|
|
|
def test_fetch_failure_returns_network_error_message(self, tmp_path):
|
|
"""When git fetch fails, return a human-readable connection error."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
# Call sequence: fetch
|
|
mock_run_git.side_effect = [
|
|
('', False), # fetch fails
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
msg = result['message'].lower()
|
|
assert 'could not reach' in msg or 'internet connection' in msg or 'remote repository' in msg
|
|
|
|
def test_fetch_failure_does_not_attempt_pull(self, tmp_path):
|
|
"""When fetch fails, pull is never called."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', False), # fetch fails
|
|
]
|
|
updates._apply_update_inner('webui')
|
|
# Only fetch is called. No target selection or pull call.
|
|
assert mock_run_git.call_count == 1
|
|
|
|
# ------------------------------------------------------------------
|
|
# Path 2: pull fails + diverged history
|
|
# ------------------------------------------------------------------
|
|
|
|
def test_diverged_history_returns_reset_hard_command(self, tmp_path):
|
|
"""Diverged history produces a message with 'reset --hard'."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True), # fetch succeeds
|
|
('', True), # no release tags
|
|
('origin/master', True), # upstream query
|
|
('', True), # status --porcelain (clean)
|
|
('Not possible to fast-forward, aborting.', False), # pull fails
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
assert result.get('diverged') is True
|
|
msg = result['message']
|
|
assert 'reset --hard' in msg
|
|
|
|
def test_diverged_history_message_contains_compare_ref(self, tmp_path):
|
|
"""Diverged history message includes the upstream ref."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True), # fetch
|
|
('', True), # no release tags
|
|
('origin/feat/my-feature', True), # upstream query
|
|
('', True), # status (clean)
|
|
('Your branch and origin have diverged.', False), # pull
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
assert 'origin/feat/my-feature' in result['message']
|
|
|
|
def test_diverged_matching_is_case_insensitive(self, tmp_path):
|
|
"""'DIVERGED' in uppercase is still detected."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True),
|
|
('', True),
|
|
('origin/master', True),
|
|
('', True),
|
|
('DIVERGED from upstream', False),
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
assert result.get('diverged') is True
|
|
|
|
# ------------------------------------------------------------------
|
|
# Path 3: pull fails + no upstream tracking configured
|
|
# ------------------------------------------------------------------
|
|
|
|
def test_no_tracking_returns_set_upstream_command(self, tmp_path):
|
|
"""Missing upstream tracking branch produces set-upstream-to message."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True), # fetch
|
|
('', True), # no release tags
|
|
('origin/master', True), # upstream query
|
|
('', True), # status (clean)
|
|
('There is no tracking information for the current branch.', False), # pull
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
assert 'set-upstream-to' in result['message']
|
|
assert result.get('diverged') is None
|
|
|
|
def test_no_tracking_alternate_phrasing(self, tmp_path):
|
|
"""'does not track' alternate git message is also detected."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True),
|
|
('', True),
|
|
('origin/master', True),
|
|
('', True),
|
|
('fatal: The current branch local does not track a remote branch.', False),
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
assert 'set-upstream-to' in result['message']
|
|
|
|
def test_no_tracking_message_contains_compare_ref(self, tmp_path):
|
|
"""set-upstream-to message includes the upstream ref to configure."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True),
|
|
('', True),
|
|
('origin/main', True),
|
|
('', True),
|
|
('no tracking information', False),
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
assert 'origin/main' in result['message']
|
|
|
|
# ------------------------------------------------------------------
|
|
# Path 4: pull fails + generic fallback (truncated raw output)
|
|
# ------------------------------------------------------------------
|
|
|
|
def test_generic_failure_includes_truncated_git_output(self, tmp_path):
|
|
"""Generic pull failure includes up to 300 chars of git output."""
|
|
(tmp_path / '.git').mkdir()
|
|
long_error = 'X' * 500 # 500-char error from git
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True),
|
|
('', True),
|
|
('origin/master', True),
|
|
('', True),
|
|
(long_error, False),
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
msg = result['message']
|
|
# The raw output in the message must be truncated at 300 chars
|
|
assert 'X' * 300 in msg
|
|
assert 'X' * 301 not in msg
|
|
|
|
def test_generic_failure_empty_output_shows_sentinel(self, tmp_path):
|
|
"""When git produces no output, message contains a fallback sentinel."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True),
|
|
('', True),
|
|
('origin/master', True),
|
|
('', True),
|
|
('', False), # pull fails with empty output
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
assert 'no output' in result['message'].lower() or result['message']
|
|
|
|
def test_generic_failure_does_not_set_diverged(self, tmp_path):
|
|
"""A generic pull failure must not set diverged=True."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', True),
|
|
('', True),
|
|
('origin/master', True),
|
|
('', True),
|
|
('Some unrecognized git error', False),
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is False
|
|
assert not result.get('diverged')
|
|
|
|
# ------------------------------------------------------------------
|
|
# Regression: existing success path still works after fetch addition
|
|
# ------------------------------------------------------------------
|
|
|
|
def test_successful_update_still_returns_ok(self, tmp_path):
|
|
"""Fetch + status + pull success path returns ok=True (regression guard)."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
# Patch the cache's 'checked_at' key directly to avoid the lock
|
|
# invalidation block raising. We use a fresh dict swap.
|
|
fake_cache = {'webui': None, 'agent': None, 'checked_at': 1}
|
|
with patch(f'{_MODULE}.REPO_ROOT', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git, \
|
|
patch(f'{_MODULE}._update_cache', fake_cache), \
|
|
patch(f'{_MODULE}._cache_lock'):
|
|
mock_run_git.side_effect = [
|
|
('', True), # fetch succeeds
|
|
('', True), # no release tags
|
|
('origin/master', True), # upstream query
|
|
('', True), # status (clean working tree)
|
|
('Already up to date.', True), # pull succeeds
|
|
]
|
|
result = updates._apply_update_inner('webui')
|
|
|
|
assert result['ok'] is True
|
|
|
|
# ------------------------------------------------------------------
|
|
# Agent target works the same as webui target
|
|
# ------------------------------------------------------------------
|
|
|
|
def test_fetch_failure_for_agent_target(self, tmp_path):
|
|
"""Fetch failure path also works when target='agent'."""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}._AGENT_DIR', tmp_path), \
|
|
patch(f'{_MODULE}._run_git') as mock_run_git:
|
|
mock_run_git.side_effect = [
|
|
('', False), # fetch fails
|
|
]
|
|
result = updates._apply_update_inner('agent')
|
|
|
|
assert result['ok'] is False
|
|
assert 'could not reach' in result['message'].lower() or \
|
|
'internet' in result['message'].lower() or \
|
|
'remote' in result['message'].lower()
|
|
|
|
|
|
# Issue #4085 regression: a dirty install at-or-past the latest release tag
|
|
# must surface `dirty: True` on the check payload so the Settings panel can
|
|
# offer `apply_force_update` instead of the silent "Up to date" state.
|
|
class TestCheckRepoDirtyFlag:
|
|
def test_dirty_tree_surfaces_dirty_true(self, tmp_path):
|
|
"""A dirty tree on a network-failed check must still carry dirty=True.
|
|
|
|
The Settings panel needs the dirty flag on every payload shape so a
|
|
user can always recover from a local-modifications state, even when
|
|
the latest remote cannot be reached.
|
|
"""
|
|
(tmp_path / '.git').mkdir()
|
|
|
|
def fake_git(args, cwd, timeout=10):
|
|
if args == ['diff-index', '--quiet', 'HEAD', '--']:
|
|
return '', False # dirty
|
|
if args == ['fetch', 'origin', '--tags', '--force']:
|
|
return 'network unavailable', False # fail fast
|
|
if args == ['tag', '--list', 'v*', '--sort=-v:refname']:
|
|
return '', True
|
|
raise AssertionError(f'unexpected git args: {args!r}')
|
|
|
|
from api import updates
|
|
with patch(f'{_MODULE}._run_git', side_effect=fake_git):
|
|
info = updates._check_repo(tmp_path, 'webui')
|
|
|
|
assert info is not None
|
|
assert info['dirty'] is True
|
|
assert info['stale_check'] is True
|