fix: fail closed on busy or unconfirmed native repair evidence

This commit is contained in:
阿白叔 committed 2026-11-02 18:27:19 +08:00
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.
+55 -1
View File
@@ -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'):
+4 -2
View File
@@ -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'))):
+13 -4
View File
@@ -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
View File
@@ -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