Files
cbb-refresh-verify-795/tests/test_issue17_cleanup.py

230 lines
12 KiB
Python

"""Field #17: data failures finish their own cleanup before the next writer."""
import json
import time
from dataclasses import replace
from pathlib import Path
from types import SimpleNamespace
import pytest
from cbb_refresh_verify import failed_session, verify_runner
from cbb_refresh_verify.models import CbbRecord, LibraryReadResult
def test_database_load_question_declines_log_view_then_closes_empty_target(tmp_path, monkeypatch):
import win32con
from test_failed_startup import read_write_fixture
job, records, messages, names, _ = read_write_fixture(tmp_path, monkeypatch)
names[203] = ('Problem encountered while opening one of the database files. '
'See PCBLogFile.txt for details. Loading of the job has failed.\r\r'
'Do you wish to view the log file now?')
result = failed_session.close_failed_startup(job, 12, timeout_seconds=0)
assert result['status'] == 'CLOSED', result
assert messages == [(202, win32con.BM_CLICK), (100, win32con.WM_CLOSE)]
assert not records
@pytest.mark.parametrize('text', [
'Problem encountered while opening one of the database files. Delete database?',
'Loading of the job has failed. Do you wish to repair it?',
])
def test_unknown_database_question_is_preserved(tmp_path, monkeypatch, text):
from test_failed_startup import read_write_fixture
job, records, messages, names, _ = read_write_fixture(tmp_path, monkeypatch)
names[203] = text
result = failed_session.close_failed_startup(job, 12, timeout_seconds=0)
assert result['status'] == 'RETAINED' and records and not messages
def test_supervisor_acknowledged_failed_open_can_close_empty_shell_with_address(tmp_path, monkeypatch):
import win32con
from cbb_refresh_verify.dialog_models import WindowSnapshot, ControlSnapshot, DialogPhase
from test_failed_startup import startup_fixture
job, records, messages = startup_fixture(tmp_path, monkeypatch)
address = tmp_path/'database/cdbsvr/sAddress.adr'
address.parent.mkdir(parents=True)
address.write_text('original address')
popup = WindowSnapshot(200,12,'ExpeditionPCB.exe','pcb','#32770','Expedition PCB',
DialogPhase.PCB_STARTING, (
ControlSnapshot(201,6,'Button','Yes'), ControlSnapshot(202,7,'Button','No'),
ControlSnapshot(203,65535,'Static',
'Problem encountered while opening one of the database files. '
'See PCBLogFile.txt for details. Loading of the job has failed.\r\r'
'Do you wish to view the log file now?')))
(tmp_path/'dialogs.jsonl').write_text(json.dumps(dict(popup.to_record(),
action='acknowledge_fatal', error_code='MENTOR_DATABASE_LOAD_FAILED', accepted_control=[7]))+'\n')
result = failed_session.close_failed_startup(job, 12, timeout_seconds=0)
assert result['status'] == 'CLOSED', result
assert messages == [(100,win32con.WM_CLOSE)]
assert not records and address.read_text() == 'original address'
@pytest.mark.parametrize('aliased', [False, True])
def test_late_release_is_rechecked_before_later_same_library_item(tmp_path, monkeypatch, aliased):
library = tmp_path/'lib.lmc'
calls, checks = [], []
failed = verify_runner.VerifyResult('FAIL', stderr='bad database', safe_to_continue=False,
evidence_path=tmp_path/'result.json', error_category='MENTOR_DATABASE_LOAD_FAILED')
def verify(request):
calls.append(request.block_name)
return failed if request.block_name == 'Bad' else verify_runner.VerifyResult('PASS')
def recheck(library, block, result, **kwargs):
checks.append(block)
return result if len(checks) == 1 else replace(result, safe_to_continue=True)
monkeypatch.setattr('cbb_refresh_verify.operation_lifecycle.recheck_failed_release', recheck)
if aliased:
monkeypatch.setattr('cbb_refresh_verify.operation_queue.request_library_keys',
lambda *args:{'display-path','mapped-path'})
results = verify_runner.run_batch([verify_runner.VerifyRequest(library, n, tmp_path)
for n in ('Bad','Good')], verifier=verify)
assert calls == ['Bad','Good']
assert [r.status for r in results] == ['FAIL','PASS']
assert results[0].safe_to_continue
def test_slow_catalog_status_is_delivered_and_unknown_cannot_start_bulk(qtbot, tmp_path, monkeypatch):
from test_issue15_ui_integration import window_for
from cbb_refresh_verify.management import Catalog, CatalogEntry
from threading import Event
entered, release = Event(), Event()
def statuses(names, library):
entered.set()
assert release.wait(15)
return {name:'READY' for name in names}
window = window_for(qtbot, tmp_path, monkeypatch,
reader=lambda _: LibraryReadResult((CbbRecord('A','LP'),), directory_count=1),
catalog_reader=lambda p,e:Catalog(p,1,(CatalogEntry('A','Logical-Physical'),)),
status_refresher=statuses)
window.lmc_edit.setText('a.lmc')
window.load_library()
qtbot.waitUntil(entered.is_set)
try:
assert not window.batch_button.isEnabled()
assert window.backup_restore_button.isEnabled()
assert '待读取 1' in window.counts_label.text()
# Actual prior metadata cutoff; native IO is simulated, task/Qt delivery is real.
qtbot.wait(10300)
release.set()
qtbot.waitUntil(lambda:window.ready_names == {'A'}, timeout=3000)
assert '原生 1' in window.counts_label.text()
finally:
release.set()
window.pool.waitForDone(5000)
def test_successful_worker_does_not_report_retained_save(tmp_path, monkeypatch):
from test_verify_worker_stability import exercise_worker
job, events, execute = exercise_worker(tmp_path, monkeypatch)
assert execute()['status'] == 'PASS'
assert not [e for e in events if e.get('stage') == 'save_result_retained']
@pytest.mark.parametrize('fresh', ['UNKNOWN', 'UNAVAILABLE', None])
def test_execution_rechecks_status_without_starting_unknown_target(qtbot, tmp_path, monkeypatch, fresh):
from test_issue15_ui_integration import window_for
from cbb_refresh_verify.management import Catalog, CatalogEntry
calls, reads = [], []
def statuses(names, library):
reads.append(tuple(names))
return {'A':'PENDING'} if len(reads) == 1 else ({} if fresh is None else {'A':fresh})
window = window_for(qtbot,tmp_path,monkeypatch,
reader=lambda _:LibraryReadResult((CbbRecord('A','LP'),), directory_count=1),
catalog_reader=lambda p,e:Catalog(p,1,(CatalogEntry('A','Logical-Physical'),)),
status_refresher=statuses,
verifier=lambda request:(calls.append(request.block_name) or verify_runner.VerifyResult('PASS')))
window.lmc_edit.setText('a.lmc'); window.load_library()
qtbot.waitUntil(lambda:window._read_counts[1] == 1)
window._run(['A'])
qtbot.waitUntil(lambda:not window.busy)
assert calls == []
reports=list((tmp_path/'reports').glob('batch-*.log'))
assert reports and 'STATUS_UNCONFIRMED' in reports[0].read_text(encoding='utf-8')
@pytest.mark.parametrize('second_ready', [True,False])
def test_saved_closed_pending_commit_gets_only_one_followup(tmp_path, monkeypatch, second_ready):
root=tmp_path/'first';root.mkdir()
evidence=root/'result.json';evidence.write_text('{"status":"FAIL"}')
second=tmp_path/'second';second.mkdir()
second_evidence=second/'result.json';second_evidence.write_text('{}')
pending=verify_runner.VerifyResult('FAIL',safe_to_continue=True,evidence_path=evidence,
library_flag='NOT_GREEN',error_category='MENTOR_VERIFY_NOT_COMMITTED',error_stage='library_flag',
bridge_attempts=({'status':'PENDING','source':'IsVerifiedReuseBlock','raw_status':0},),
timings_seconds={'total':2.0},
write_outcome=dict(save_state='COMMITTED',close_state='CLOSED',helper_state='EXITED',
resource_state='RELEASED',interrupted=False))
calls=[]
def serialized(request,**kwargs):
calls.append(request.block_name)
if len(calls)==1:return pending
return (verify_runner.VerifyResult('PASS',library_flag='GREEN',evidence_path=second_evidence,timings_seconds={'total':3.0})
if second_ready else replace(pending,evidence_path=second_evidence,timings_seconds={'total':3.0}))
monkeypatch.setattr(verify_runner,'_run_verify_serialized',serialized)
result=verify_runner._run_verify_task(verify_runner.VerifyRequest(tmp_path/'missing.lmc','Block',tmp_path))
assert calls == ['Block','Block']
assert result.status == ('PASS' if second_ready else 'FAIL')
assert result.timings_seconds['total']==5.0
assert json.loads(evidence.read_text()) == {'status':'FAIL'}
link=json.loads((root/'commit-followup.json').read_text())
assert link['status']==('READY' if second_ready else 'UNCONFIRMED')
@pytest.mark.parametrize('obstacle', ['unsafe','save_unknown','close_unknown','native_retained',
'helper_running','interrupted','database_failure','unknown_status','diagnostic','auto_repair','cancelled'])
def test_incomplete_or_failed_native_operation_never_gets_commit_followup(tmp_path,monkeypatch,obstacle):
from threading import Event
evidence=tmp_path/'result.json';evidence.write_text('{}')
facts=dict(save_state='COMMITTED',close_state='CLOSED',helper_state='EXITED',resource_state='RELEASED',interrupted=False)
if obstacle=='save_unknown':facts['save_state']='UNKNOWN'
if obstacle=='close_unknown':facts['close_state']='UNKNOWN'
if obstacle=='native_retained':facts['resource_state']='RETAINED'
if obstacle=='helper_running':facts['helper_state']='RUNNING'
if obstacle=='interrupted':facts['interrupted']=True
pending=verify_runner.VerifyResult('FAIL',safe_to_continue=obstacle!='unsafe',evidence_path=evidence,
library_flag='NOT_GREEN' if obstacle!='unknown_status' else 'UNKNOWN',
error_category='MENTOR_DATABASE_LOAD_FAILED' if obstacle=='database_failure' else 'MENTOR_VERIFY_NOT_COMMITTED',
error_stage='library_flag',bridge_attempts=({'status':'PENDING','source':'IsVerifiedReuseBlock','raw_status':0},),
write_outcome=facts)
stop=Event();calls=[]
def serialized(*args,**kwargs):
calls.append(1)
if obstacle=='cancelled':stop.set()
return pending
monkeypatch.setattr(verify_runner,'_run_verify_serialized',serialized)
verify_runner._run_verify_task(verify_runner.VerifyRequest(tmp_path/'missing.lmc','Block',tmp_path,
diagnostic_only=obstacle=='diagnostic',auto_repair=obstacle=='auto_repair'),stop=stop)
assert calls == [1]
assert not (tmp_path/'commit-followup.json').exists()
def test_cancel_after_followup_checkpoint_releases_completed_first_lease(tmp_path,monkeypatch):
from cbb_refresh_verify.operation_queue import BatchTaskContext, QueueCancelled
from cbb_refresh_verify import library_lock
import win32con, win32file
library=tmp_path/'lib.lmc';library.write_bytes(b'isolated fixture')
evidence=tmp_path/'result.json';evidence.write_text('{}')
pending=verify_runner.VerifyResult('FAIL',safe_to_continue=True,evidence_path=evidence,
library_flag='NOT_GREEN',error_category='MENTOR_VERIFY_NOT_COMMITTED',error_stage='library_flag',
write_outcome=dict(save_state='COMMITTED',close_state='CLOSED',helper_state='EXITED',resource_state='RELEASED',interrupted=False))
monkeypatch.setattr(library_lock,'recheck_previous_release',lambda *a,**k:None)
monkeypatch.setattr(verify_runner,'_run_verify_serialized',lambda *a,**k:pending)
context=BatchTaskContext(str(library))
original=Path.write_text
def write(path,*a,**k):
result=original(path,*a,**k)
if path.name=='commit-followup.json':context.cancel()
return result
monkeypatch.setattr(Path,'write_text',write)
try:
with pytest.raises(QueueCancelled):
context.run(lambda:verify_runner._run_verify_task(
verify_runner.VerifyRequest(library,'Block',tmp_path),stop=context.stop))
lock=library_lock.LibraryLock(library)
handle=win32file.CreateFile(str(lock.path),win32con.GENERIC_READ,0,None,win32con.OPEN_EXISTING,0,None)
handle.Close()
finally:
context.close(timeout_seconds=0)
with library_lock._guard:
owner=library_lock._owners.pop(library_lock.LibraryLock(library).key,None)
if owner:owner['handle'].Close()