fix: fail closed on busy or unconfirmed native repair evidence
This commit is contained in:
1 parent
aa760c2839
commit
c823a4b92d
5 files changed
+267
-24
No files matched your search
@@ -100,7 +100,11 @@ cooperative close only after a terminal native error, an enabled exact-project
|
||||
main window, no other windows/prompts and no target database address. The worker
|
||||
then waits for normal process exit. Unknown/custom prompts and incomplete native
|
||||
operations receive no close action. A failure classification can coexist with
|
||||
unreleased state; that state always stops the queue. A busy-project message in
|
||||
unreleased state; that state always stops the queue. Terminal `DATABASE_BUSY`
|
||||
errors also retain the native tool without close, reopen or queue continuation.
|
||||
Unreadable, absent, hung or truncated initial Output waits within the deadline
|
||||
and retains the tool without requesting Repair; a readable empty string is a
|
||||
valid invocation baseline. A busy-project message in
|
||||
this fresh native process's initial loading Output prevents Repair invocation
|
||||
entirely; it is not hidden by the later invocation baseline.
|
||||
|
||||
@@ -112,10 +116,17 @@ Only a conclusively failed, released, independently revalidated project-local
|
||||
target may allow the next CBB. Shared or unknown scope, busy owners, timeouts,
|
||||
unknown prompts and historical restores stop for review.
|
||||
|
||||
Before accepting native success, the parent validates native process identity
|
||||
and true exit, exact project/database, empty address state, confirmed backup/
|
||||
repair evidence and absence of restore/failure/unknown-prompt contradictions.
|
||||
Missing or wrong-typed fields fail closed. Independent process, address and
|
||||
database-handle probes remain additional requirements.
|
||||
|
||||
Native `REPAIRED` is retained as `native_status`; summaries count a repair only
|
||||
after the same request reopens, completes Verify and returns authoritative
|
||||
`PASS/GREEN` with confirmed release. A failed reopen becomes
|
||||
`REPAIR_VALIDATION_FAILED`; an unconfirmed native release prevents reopening.
|
||||
`REPAIR_VALIDATION_FAILED`; incomplete or contradictory native success/release
|
||||
becomes `UNCONFIRMED` and prevents reopening.
|
||||
Historical restoration remains `RESTORED_REVIEW_REQUIRED`. The original error,
|
||||
stage and evidence references, a `pre-repair-result.json` snapshot, native
|
||||
evidence and validation evidence remain attached even if the retry raises.
|
||||
@@ -139,3 +150,8 @@ Task 1 checks: full suite once, 532 passed with the existing pywinauto COM warni
|
||||
after the final initial-busy gate regression, the related final suite passed all
|
||||
234 tests. Compileall and `git diff --check` passed. The coordinator will run
|
||||
candidate/frozen validation against the final implementation.
|
||||
|
||||
Task 1 review fix round: 259 related tests passed (17.86s); compileall and
|
||||
`git diff --check` passed. These checks include busy retention, real readback
|
||||
failure branches, 30 malformed-success variants at both release and reopen/
|
||||
counting boundaries, and a complete actual worker-result replay control.
|
||||
@@ -140,7 +140,11 @@ def attempt_recovery(request, diagnosis, evidence_root, *, progress=None):
|
||||
callback = (lambda event: progress({'block': request.block_name, **event})) if progress else None
|
||||
record = run_native_repair(target, root, mentor_bin=request.mentor_bin,
|
||||
timeout_seconds=max(60, request.timeout_seconds), progress=callback)
|
||||
native_status = record.get('status')
|
||||
record['release'] = repair_release_state(request, target, record)
|
||||
if native_status == 'REPAIRED' and record['release']['safe_to_continue'] is not True:
|
||||
record.update(status='UNCONFIRMED', native_status=native_status,
|
||||
detail='NATIVE_REPAIR_EVIDENCE_UNCONFIRMED: 原生成功或释放证据不完整')
|
||||
record['evidence_path'] = str(root)
|
||||
except Exception as error:
|
||||
record['detail'] = str(error)
|
||||
@@ -148,14 +152,64 @@ def attempt_recovery(request, diagnosis, evidence_root, *, progress=None):
|
||||
return record
|
||||
|
||||
|
||||
def _native_identity_and_exit_confirmed(target, record):
|
||||
if not isinstance(record, dict):
|
||||
return False
|
||||
release = record.get('release')
|
||||
if (not isinstance(release, dict) or release.get('safe_to_continue') is not True
|
||||
or release.get('native_exited') is not True
|
||||
or not isinstance(release.get('addresses'), list) or release['addresses']
|
||||
or type(record.get('native_pid')) is not int or record['native_pid'] <= 0
|
||||
or not isinstance(record.get('unknown_dialogs', []), list)
|
||||
or record.get('unknown_dialogs')):
|
||||
return False
|
||||
try:
|
||||
for name, expected in (('project', target.project), ('database', target.database)):
|
||||
path = record.get(name)
|
||||
if (not isinstance(path, str) or not Path(path).is_absolute()
|
||||
or Path(path).resolve(strict=True) != expected.resolve(strict=True)):
|
||||
return False
|
||||
except (OSError, ValueError):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def native_success_confirmed(target, record):
|
||||
"""Validate the worker's complete, consistent success before any reopening."""
|
||||
if not _native_identity_and_exit_confirmed(target, record) or record.get('status') != 'REPAIRED':
|
||||
return False
|
||||
evidence = record.get('evidence')
|
||||
if (not isinstance(evidence, dict) or evidence.get('confirmed') is not True
|
||||
or evidence.get('native_backup') is not True
|
||||
or evidence.get('outcome') != 'UNCONFIRMED'
|
||||
or evidence.get('failure_complete') is not False
|
||||
or evidence.get('restore_complete') is not False
|
||||
or evidence.get('restored_from_backup') != ''):
|
||||
return False
|
||||
fields = ('diagnostic_tail', 'database_tail', 'restore_tail', 'output_tail')
|
||||
if any(not isinstance(evidence.get(field), str) for field in fields):
|
||||
return False
|
||||
if not evidence['diagnostic_tail'] or not evidence['database_tail']:
|
||||
return False
|
||||
from .native_repair_ui import classify_repair_evidence
|
||||
return (classify_repair_evidence(*(evidence[field] for field in fields))['outcome'] == 'UNCONFIRMED'
|
||||
and 'iCDB database restored from backup:' not in evidence['restore_tail'])
|
||||
|
||||
|
||||
def repair_release_state(request, target, native_result):
|
||||
"""Require normal exit, owner/address absence and exclusive database access."""
|
||||
from .mentor_adapter import pcb_processes, _process_details
|
||||
from .icdb_ownership import database_directories, unreleased_addresses
|
||||
from .verify_runner import preflight
|
||||
result = {**native_result.get('release', {}), 'safe_to_continue': False,
|
||||
release = native_result.get('release') if isinstance(native_result, dict) else None
|
||||
result = {**(release if isinstance(release, dict) else {}), 'safe_to_continue': False,
|
||||
'database_exclusive': False}
|
||||
try:
|
||||
if (not _native_identity_and_exit_confirmed(target, native_result)
|
||||
or (native_result.get('status') == 'REPAIRED'
|
||||
and not native_success_confirmed(target, native_result))):
|
||||
result['error'] = 'NATIVE_REPAIR_EVIDENCE_UNCONFIRMED'
|
||||
return result
|
||||
project, pcb = preflight(request)
|
||||
owners = [int(r[0]) for r in pcb_processes()]
|
||||
for name in ('LibraryManager.exe', 'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe'):
|
||||
|
||||
@@ -237,7 +237,8 @@ def repair_worker_main(job_path):
|
||||
if busy_before_start:
|
||||
output = current_output
|
||||
result.update(status='DATABASE_BUSY', detail='原生工具加载工程时报告占用;未请求 Repair')
|
||||
if not invoked and not busy_before_start and main and not dialogs and not unknown and main['enabled']:
|
||||
if (not invoked and isinstance(current_output, str) and not busy_before_start
|
||||
and main and not dialogs and not unknown and main['enabled']):
|
||||
if Path(job['cancel_signal']).exists():
|
||||
raise ValueError('REPAIR_CANCELLED_BEFORE_START')
|
||||
output_baseline = current_output
|
||||
@@ -275,7 +276,8 @@ def repair_worker_main(job_path):
|
||||
if result['status'] == 'UNKNOWN_DIALOG' or busy_before_start:
|
||||
break
|
||||
if confirmed and not closing and main and not dialogs and main['enabled']:
|
||||
if (not (database/'cdbsvr/sAddress.adr').exists() and (
|
||||
if (evidence['outcome'] != 'DATABASE_BUSY'
|
||||
and not (database/'cdbsvr/sAddress.adr').exists() and (
|
||||
evidence['failure_complete'] or evidence['confirmed'] or (evidence.get('restore_complete')
|
||||
and evidence['native_backup']
|
||||
and evidence['outcome'] == 'UNCONFIRMED'))):
|
||||
|
||||
@@ -533,7 +533,19 @@ def run_verify(request, *, progress=None, flag_reader=None, process_runner=None,
|
||||
'original_evidence': str(original.evidence_path),
|
||||
'original_result_snapshot': str(snapshot),
|
||||
'original_stage': original.error_stage,
|
||||
'native_status': recovery.get('status'), 'validation_passed': False}
|
||||
'native_status': recovery.get('native_status', recovery.get('status')),
|
||||
'validation_passed': False}
|
||||
if recovery.get('status') == 'REPAIRED':
|
||||
from .native_repair import native_success_confirmed, select_repair_target
|
||||
try:
|
||||
confirmed = native_success_confirmed(select_repair_target(request, diagnosis), recovery)
|
||||
except (ValueError, OSError):
|
||||
confirmed = False
|
||||
if not confirmed:
|
||||
release = recovery.get('release')
|
||||
recovery.update(status='UNCONFIRMED',
|
||||
release={**(release if isinstance(release, dict) else {}), 'safe_to_continue': False},
|
||||
detail='NATIVE_REPAIR_EVIDENCE_UNCONFIRMED: 原生成功记录不完整或矛盾,未重试校验')
|
||||
if (recovery.get('status') == 'REPAIRED'
|
||||
and recovery.get('release', {}).get('safe_to_continue') is True):
|
||||
result = replace(original, recovery_attempts=(recovery,))
|
||||
@@ -552,9 +564,6 @@ def run_verify(request, *, progress=None, flag_reader=None, process_runner=None,
|
||||
stderr=(result.stderr+'\nREPAIR_VALIDATION_UNCONFIRMED: 未取得校验 GREEN').strip())
|
||||
else:
|
||||
recovery['status'] = 'REPAIRED'
|
||||
elif recovery.get('status') == 'REPAIRED':
|
||||
recovery['status'] = 'REPAIR_RELEASE_UNCONFIRMED'
|
||||
result = replace(result, safe_to_continue=False)
|
||||
else:
|
||||
# A failed local database must not block unrelated CBBs once
|
||||
# every owner is released. Re-check target ownership here so
|
||||
|
||||
+177
-15
@@ -16,6 +16,19 @@ def target_fixture(tmp_path):
|
||||
return request(tmp_path), diagnosis, select_repair_target(request(tmp_path), diagnosis)
|
||||
|
||||
|
||||
def complete_native_success(target):
|
||||
"""A complete successful worker result, with no contradictory native state."""
|
||||
return {'status': 'REPAIRED', 'project': str(target.project), 'database': str(target.database),
|
||||
'native_pid': 777,
|
||||
'release': {'native_exited': True, 'safe_to_continue': True, 'addresses': []},
|
||||
'evidence': {'confirmed': True, 'native_backup': True, 'outcome': 'UNCONFIRMED',
|
||||
'failure_complete': False, 'restore_complete': False, 'restored_from_backup': '',
|
||||
'diagnostic_tail': 'Diagnostic: START\nDiagnostic: FINISH',
|
||||
'database_tail': f'{target.database}\niCDBProjectBackupRepair\nIC: Closing project',
|
||||
'restore_tail': '', 'output_tail': '', 'backup_log_tail': '',
|
||||
'log_paths': []}}
|
||||
|
||||
|
||||
def test_repair_target_matches_actual_database_not_guessed_cbb_name(tmp_path):
|
||||
request, record, target = target_fixture(tmp_path)
|
||||
assert target.project.name == 'CBB1.prj'
|
||||
@@ -135,8 +148,7 @@ def test_automatic_repair_retries_only_once_and_preserves_original_failure(tmp_p
|
||||
calls.append(req)
|
||||
return original
|
||||
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
|
||||
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw:
|
||||
{'status':'REPAIRED', 'release': {'safe_to_continue': True}})
|
||||
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: complete_native_success(target))
|
||||
outcome = runner.run_verify(request)
|
||||
assert len(calls) == 2
|
||||
assert outcome.status == 'FAIL'
|
||||
@@ -379,7 +391,7 @@ def repair_worker_fixture(tmp_path, monkeypatch, scenario):
|
||||
|
||||
|
||||
@pytest.mark.parametrize('scenario,expected,closed', [
|
||||
('failed', 'MISSING_HEALTHY_BACKUP', True), ('busy', 'DATABASE_BUSY', True),
|
||||
('failed', 'MISSING_HEALTHY_BACKUP', True), ('busy', 'DATABASE_BUSY', False),
|
||||
('unknown', 'UNKNOWN_DIALOG', False), ('custom_prompt', 'UNKNOWN_DIALOG', False),
|
||||
('active', 'TIMEOUT_UNRELEASED', False),
|
||||
('stale', 'TIMEOUT_UNRELEASED', False), ('address', 'MISSING_HEALTHY_BACKUP', False),
|
||||
@@ -399,6 +411,7 @@ def test_native_worker_closes_only_conclusively_failed_idle_tool(tmp_path, monke
|
||||
|
||||
@pytest.mark.parametrize('scenario,expected', [('success', 'REPAIRED'), ('restore', 'RESTORED_REVIEW_REQUIRED')])
|
||||
def test_native_worker_preserves_success_and_historical_restore_distinction(tmp_path, monkeypatch, scenario, expected):
|
||||
from cbb_refresh_verify.native_repair import RepairTarget, native_success_confirmed
|
||||
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, scenario)
|
||||
assert ui.repair_worker_main(job) == (0 if scenario == 'success' else 1)
|
||||
result = json.loads((root/'repair-result.json').read_text('utf-8'))
|
||||
@@ -407,6 +420,9 @@ def test_native_worker_preserves_success_and_historical_restore_distinction(tmp_
|
||||
assert result['evidence']['native_backup'] is True
|
||||
assert result['evidence']['confirmed'] is (scenario == 'success')
|
||||
assert (root/'native-logs/dbcheck/new-777/log.txt').exists()
|
||||
request = json.loads(job.read_text('utf-8'))
|
||||
target = RepairTarget(Path(request['project']), Path(request['database']))
|
||||
assert native_success_confirmed(target, result) is (scenario == 'success')
|
||||
|
||||
|
||||
def test_native_busy_project_on_load_never_invokes_repair(tmp_path, monkeypatch):
|
||||
@@ -418,6 +434,80 @@ def test_native_busy_project_on_load_never_invokes_repair(tmp_path, monkeypatch)
|
||||
assert not result['release']['safe_to_continue']
|
||||
|
||||
|
||||
@pytest.mark.parametrize('readback', ['missing', 'timeout', 'truncated'])
|
||||
def test_unavailable_initial_output_never_requests_or_confirms_repair(tmp_path, monkeypatch, readback):
|
||||
from types import SimpleNamespace
|
||||
from cbb_refresh_verify import native_repair_ui as module
|
||||
actual_read = module._native_output
|
||||
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'active')
|
||||
windows = ui._windows
|
||||
def observe(pid):
|
||||
result = windows(pid)
|
||||
if readback != 'missing':
|
||||
result[0]['children'].append({'hwnd': 400, 'class': 'RichEdit20A'})
|
||||
return result
|
||||
monkeypatch.setattr(ui, '_windows', observe)
|
||||
class Readback:
|
||||
def __call__(self, hwnd, message, length, buffer, flags, timeout, copied):
|
||||
if readback == 'timeout': return 0
|
||||
copied._obj.value = length-1
|
||||
return 1
|
||||
monkeypatch.setattr(ui.ctypes, 'WinDLL', lambda *a, **kw: SimpleNamespace(SendMessageTimeoutW=Readback()))
|
||||
monkeypatch.setattr(ui, '_native_output', actual_read)
|
||||
assert ui.repair_worker_main(job) == 1
|
||||
result = json.loads((root/'repair-result.json').read_text('utf-8'))
|
||||
assert actions == []
|
||||
assert result['status'] == 'TIMEOUT_UNRELEASED'
|
||||
assert result['release']['safe_to_continue'] is False
|
||||
assert json.loads((root/'native-output.json').read_text('utf-8'))['baseline'] is None
|
||||
|
||||
|
||||
def test_initial_output_waits_until_readable_and_accepts_empty_baseline(tmp_path, monkeypatch):
|
||||
import win32con
|
||||
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'active')
|
||||
reads = []
|
||||
def output(_):
|
||||
reads.append(len(reads))
|
||||
if len(reads) <= 2:
|
||||
assert not actions
|
||||
return None
|
||||
return ''
|
||||
monkeypatch.setattr(ui, '_native_output', output)
|
||||
assert ui.repair_worker_main(job) == 1
|
||||
assert actions == [(100, win32con.WM_COMMAND), (201, win32con.BM_CLICK)]
|
||||
assert json.loads((root/'native-output.json').read_text('utf-8'))['baseline'] == ''
|
||||
|
||||
|
||||
def test_invoked_busy_native_result_never_reopens_or_continues_queue(tmp_path, monkeypatch):
|
||||
import win32con
|
||||
from test_verify_runner import request
|
||||
from cbb_refresh_verify import verify_runner as runner, native_repair
|
||||
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'busy')
|
||||
assert ui.repair_worker_main(job) == 1
|
||||
busy = json.loads((root/'repair-result.json').read_text('utf-8'))
|
||||
assert (100, win32con.WM_CLOSE) not in actions
|
||||
assert busy['status'] == 'DATABASE_BUSY' and busy['release']['native_exited'] is False
|
||||
req = request(tmp_path)
|
||||
target = json.loads(job.read_text('utf-8'))
|
||||
evidence = tmp_path/'first/result.json'
|
||||
evidence.parent.mkdir()
|
||||
(evidence.parent/'diagnostics').mkdir()
|
||||
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps({
|
||||
'error_code': 'ICDB_REPAIR_REQUIRED', 'scope': 'project',
|
||||
'session': 'original-session', 'database_path': target['database']}))
|
||||
opens = []
|
||||
def verify(*a, **kw):
|
||||
opens.append('open')
|
||||
return runner.VerifyResult('FAIL', error_category='ICDB_REPAIR_REQUIRED',
|
||||
safe_to_continue=False, evidence_path=evidence)
|
||||
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
|
||||
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: busy)
|
||||
results = runner.run_batch([req, req], verifier=runner.run_verify)
|
||||
assert opens == ['open']
|
||||
assert results[0].recovery_attempts[0]['status'] == 'DATABASE_BUSY'
|
||||
assert results[0].safe_to_continue is False and results[1].status == 'SKIPPED'
|
||||
|
||||
|
||||
@pytest.mark.parametrize('status,released,scope,expected', [
|
||||
('MISSING_HEALTHY_BACKUP', True, 'project', True),
|
||||
('NATIVE_REPAIR_FAILED', True, 'project', True),
|
||||
@@ -425,6 +515,7 @@ def test_native_busy_project_on_load_never_invokes_repair(tmp_path, monkeypatch)
|
||||
('MISSING_HEALTHY_BACKUP', True, 'central_library', False),
|
||||
('MISSING_HEALTHY_BACKUP', True, 'unknown', False),
|
||||
('UNKNOWN_DIALOG', True, 'project', False), ('TIMEOUT_UNRELEASED', True, 'project', False),
|
||||
('DATABASE_BUSY', True, 'project', False),
|
||||
])
|
||||
def test_failed_repair_continues_only_released_project_local_items(
|
||||
tmp_path, monkeypatch, status, released, scope, expected):
|
||||
@@ -473,8 +564,7 @@ def test_maintenance_counts_require_native_success_then_verify_green(
|
||||
calls.append(req)
|
||||
return original if len(calls) == 1 else validated
|
||||
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
|
||||
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw:
|
||||
{'status': 'REPAIRED', 'release': {'safe_to_continue': True}})
|
||||
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: complete_native_success(target))
|
||||
result = runner.run_verify(request)
|
||||
assert len(calls) == 2 and calls[1].auto_repair is False
|
||||
assert result.recovery_attempts[0]['validation_passed'] is expected
|
||||
@@ -500,7 +590,7 @@ def test_native_success_without_release_does_not_reopen(tmp_path, monkeypatch):
|
||||
result = runner.run_verify(request)
|
||||
assert calls == ['open']
|
||||
assert not result.safe_to_continue
|
||||
assert result.recovery_attempts[0]['status'] == 'REPAIR_RELEASE_UNCONFIRMED'
|
||||
assert result.recovery_attempts[0]['status'] == 'UNCONFIRMED'
|
||||
|
||||
|
||||
@pytest.mark.parametrize('obstacle', ['none', 'launcher', 'repair_tool', 'importer', 'address', 'handle', 'shared_handle', 'probe'])
|
||||
@@ -531,8 +621,7 @@ def test_repair_release_requires_process_address_and_database_handle_release(tmp
|
||||
database_file.touch()
|
||||
handle = win32file.CreateFile(str(database_file), win32con.GENERIC_READ,
|
||||
0, None, win32con.OPEN_EXISTING, 0, None)
|
||||
result = native_repair.repair_release_state(request, target,
|
||||
{'release': {'safe_to_continue': True}})
|
||||
result = native_repair.repair_release_state(request, target, complete_native_success(target))
|
||||
assert result['safe_to_continue'] is (obstacle == 'none')
|
||||
finally:
|
||||
if handle: handle.Close()
|
||||
@@ -547,7 +636,8 @@ def test_attempt_persists_distinct_native_failure_and_release_result(tmp_path, m
|
||||
monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: [])
|
||||
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **kw: {
|
||||
'status': 'MISSING_HEALTHY_BACKUP', 'project': str(target.project),
|
||||
'database': str(target.database), 'release': {'safe_to_continue': True},
|
||||
'database': str(target.database), 'native_pid': 777,
|
||||
'release': {'safe_to_continue': True, 'native_exited': True, 'addresses': []},
|
||||
'evidence': {'failure_complete': True, 'output_tail': 'no backup'}})
|
||||
result = native_repair.attempt_recovery(request, diagnosis, evidence)
|
||||
assert result['status'] == 'MISSING_HEALTHY_BACKUP'
|
||||
@@ -572,14 +662,14 @@ def test_retry_exception_keeps_original_error_and_native_repair_evidence(tmp_pat
|
||||
return runner.VerifyResult('FAIL', stderr='original native error', safe_to_continue=False,
|
||||
error_category='ICDB_REPAIR_REQUIRED', evidence_path=evidence)
|
||||
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
|
||||
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: {
|
||||
'status': 'REPAIRED', 'release': {'safe_to_continue': True},
|
||||
'evidence': {'confirmed': True, 'diagnostic_tail': 'original repair evidence'}})
|
||||
native_result = complete_native_success(target)
|
||||
native_result['evidence']['diagnostic_tail'] += '\noriginal repair evidence'
|
||||
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: native_result)
|
||||
result = runner.run_verify(request)
|
||||
assert not result.safe_to_continue
|
||||
assert 'original native error' in result.stderr
|
||||
assert 'retry infrastructure failure' in result.stderr
|
||||
assert result.recovery_attempts[0]['evidence']['diagnostic_tail'] == 'original repair evidence'
|
||||
assert 'original repair evidence' in result.recovery_attempts[0]['evidence']['diagnostic_tail']
|
||||
assert result.recovery_attempts[0]['status'] == 'REPAIR_VALIDATION_FAILED'
|
||||
assert json.loads(evidence.read_text('utf-8'))['recovery_attempts']
|
||||
|
||||
@@ -637,8 +727,7 @@ def test_sanitized_field_open_failure_replay_closes_launcher_then_repairs_once(t
|
||||
assert trace[-1] == 'launcher_exited'
|
||||
assert not records and launcher.poll() == 0
|
||||
trace.append('native_repair')
|
||||
return {'status': 'REPAIRED', 'project': str(actual.project), 'database': str(actual.database),
|
||||
'release': {'safe_to_continue': True}, 'evidence': {'confirmed': True}}
|
||||
return complete_native_success(actual)
|
||||
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
|
||||
monkeypatch.setattr(native_repair, 'run_native_repair', repair)
|
||||
result = runner.run_verify(request)
|
||||
@@ -649,3 +738,76 @@ def test_sanitized_field_open_failure_replay_closes_launcher_then_repairs_once(t
|
||||
assert result.recovery_attempts[0]['status'] == 'REPAIR_VALIDATION_FAILED'
|
||||
assert result.recovery_attempts[0]['original_error'] == replay['native_error']
|
||||
assert json.loads((tmp_path/'pre-repair-result.json').read_text('utf-8'))['stderr'] == replay['native_error']
|
||||
|
||||
|
||||
MALFORMED_SUCCESS = [
|
||||
('minimal', None),
|
||||
('native_pid', None), ('native_pid', True),
|
||||
('project', None), ('project', '<other>/CBB.prj'), ('project', []),
|
||||
('database', None), ('database', '<other>/database'),
|
||||
('release', []), ('release', 'released'),
|
||||
('release.native_exited', None), ('release.native_exited', False),
|
||||
('release.native_exited', 1), ('release.native_exited', 'true'),
|
||||
('release.safe_to_continue', 1), ('release.addresses', ['owner']), ('release.addresses', ''),
|
||||
('evidence', None), ('evidence', []), ('evidence', 'confirmed'),
|
||||
('evidence.confirmed', None), ('evidence.confirmed', False),
|
||||
('evidence.confirmed', 1), ('evidence.confirmed', 'true'),
|
||||
('evidence.native_backup', False), ('evidence.failure_complete', True),
|
||||
('evidence.outcome', 'DATABASE_BUSY'), ('evidence.restore_complete', True),
|
||||
('evidence.restored_from_backup', 'old.zip'), ('unknown_dialogs', [{'title': 'Unknown'}]),
|
||||
]
|
||||
|
||||
|
||||
def malformed_native_success(target, key, value):
|
||||
result = complete_native_success(target)
|
||||
if key == 'minimal': return {'status': 'REPAIRED', 'release': {'safe_to_continue': True}}
|
||||
if key in {'project', 'database'} and isinstance(value, str) and value.startswith('<other>'):
|
||||
other = target.project.parent.parent.parent/'other-target'
|
||||
other.mkdir(exist_ok=True)
|
||||
if key == 'project':
|
||||
other = other/'other.prj'
|
||||
other.touch()
|
||||
value = str(other.resolve())
|
||||
if '.' in key:
|
||||
parent, field = key.split('.')
|
||||
result[parent][field] = value
|
||||
else:
|
||||
result[key] = value
|
||||
return result
|
||||
|
||||
|
||||
@pytest.mark.parametrize('key,value', MALFORMED_SUCCESS)
|
||||
def test_malformed_native_success_never_authorizes_release(tmp_path, monkeypatch, key, value):
|
||||
from cbb_refresh_verify import native_repair, mentor_adapter
|
||||
request, diagnosis, target = target_fixture(tmp_path)
|
||||
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
|
||||
monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: [])
|
||||
result = native_repair.repair_release_state(request, target, malformed_native_success(target, key, value))
|
||||
assert result['safe_to_continue'] is False
|
||||
|
||||
|
||||
@pytest.mark.parametrize('key,value', MALFORMED_SUCCESS)
|
||||
def test_malformed_native_success_never_reopens_or_counts_repaired(tmp_path, monkeypatch, key, value):
|
||||
from cbb_refresh_verify import verify_runner as runner, native_repair
|
||||
from cbb_refresh_verify.icdb_maintenance import maintenance_counts
|
||||
request, diagnosis, target = target_fixture(tmp_path)
|
||||
evidence = tmp_path/'first/result.json'
|
||||
evidence.parent.mkdir()
|
||||
(evidence.parent/'diagnostics').mkdir()
|
||||
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(diagnosis))
|
||||
calls = []
|
||||
def verify(*a, **kw):
|
||||
calls.append('open')
|
||||
if len(calls) == 1:
|
||||
return runner.VerifyResult('FAIL', stderr='original error', error_category='ICDB_REPAIR_REQUIRED',
|
||||
safe_to_continue=False, evidence_path=evidence)
|
||||
return runner.VerifyResult('PASS', library_flag='GREEN', evidence_path=evidence)
|
||||
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
|
||||
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw:
|
||||
malformed_native_success(target, key, value))
|
||||
result = runner.run_verify(request)
|
||||
assert calls == ['open']
|
||||
assert result.status == 'FAIL' and result.safe_to_continue is False
|
||||
assert result.recovery_attempts[0]['status'] == 'UNCONFIRMED'
|
||||
assert result.recovery_attempts[0]['release']['safe_to_continue'] is False
|
||||
assert maintenance_counts([result])['repaired'] == 0
|
||||
Reference in new issue
Block a user