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

305 lines
18 KiB
Python

from cbb_refresh_verify.ui import timed_prompt
import json
from contextlib import nullcontext
from pathlib import Path
import pytest
from test_residual_sessions import row, OWNERSHIP
@pytest.mark.parametrize('failure_stage', ['before_actions', 'after_actions'])
def test_snapshot_timeout_keeps_each_actual_release_result(tmp_path, monkeypatch, failure_stage):
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'library/lib.lmc'; library.parent.mkdir(); library.touch()
process = row(10, library.parent/'ReusableBlocksLP/A/Work/A.prj')
process.update(scope_confirmed=True, created_handle='creation', image=process['executable'], **OWNERSHIP)
snapshots = [0]
def snapshot():
snapshots[0] += 1
if snapshots[0] == (1 if failure_stage == 'before_actions' else 2):
raise TimeoutError('OWNER_QUERY_TIMEOUT')
return [process]
monkeypatch.setattr(sessions, 'query_process_snapshot', snapshot)
monkeypatch.setattr(sessions, '_request_close', lambda *a, **kw:
{'release_status': 'RELEASED', 'detail': 'closed'})
monkeypatch.setattr(sessions, '_finish_library_release', lambda *a: pytest.fail('snapshot failed'))
plan = {'library': str(library), 'sessions': [process]}
result = sessions._release_residual_sessions(plan, tmp_path/'evidence')
saved = json.loads(Path(result['evidence_path']).read_text('utf-8'))
assert saved['status'] == 'PARTIAL' and 'OWNER_QUERY_TIMEOUT' in saved['detail']
assert saved['sessions'][0]['release_status'] == ('NOT_STARTED' if failure_stage == 'before_actions' else 'RELEASED')
def test_first_outcome_is_durable_before_next_session_action(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'library/lib.lmc'; library.parent.mkdir(); library.touch()
processes = [dict(row(pid, library.parent/f'ReusableBlocksLP/{pid}/Work/a.prj'),
scope_confirmed=True) for pid in (10, 20)]
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: processes)
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
def close(process, **kwargs):
if process['pid'] == 20:
report = json.loads(next((tmp_path/'evidence').glob('sessions-*/result.json')).read_text('utf-8'))
assert report['sessions'][0]['release_status'] == 'RELEASED'
assert report['sessions'][1]['release_status'] == 'REQUESTING'
return {'release_status': 'RELEASED', 'detail': 'closed'}
monkeypatch.setattr(sessions, '_request_close', close)
monkeypatch.setattr(sessions, '_finish_library_release', lambda *a:
{'status': 'RELEASE_CONFIRMED', 'library': str(library)})
result = sessions._release_residual_sessions({'library': str(library), 'sessions': processes}, tmp_path/'evidence')
assert result['status'] == 'RELEASE_CONFIRMED'
def test_report_storage_failure_does_not_claim_complete_or_undo_release_proof(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'library/lib.lmc'; library.parent.mkdir(); library.touch()
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [])
monkeypatch.setattr(sessions, '_process_windows', lambda _: {})
monkeypatch.setattr(sessions, '_finish_library_release', lambda *a:
{'status': 'RELEASE_CONFIRMED', 'library': str(library)})
original = Path.open
writes = []
def deny(path, *args, **kwargs):
if path.name == 'result.pending':
writes.append(1)
if len(writes) > 1: raise PermissionError('disk full after release')
return original(path, *args, **kwargs)
monkeypatch.setattr(Path, 'open', deny)
result = sessions._release_residual_sessions({'library': str(library), 'sessions': []}, tmp_path/'evidence')
assert result['status'] == 'PARTIAL' and 'disk full' in result['evidence_error']
assert result['proof']['status'] == 'RELEASE_CONFIRMED'
@pytest.mark.parametrize('output', [None, 'Repairing project\nRepair backup created successfully.',
'Restoring project', 'Backing up project'])
def test_force_rechecks_native_backup_activity_before_termination(monkeypatch, output):
import win32api, win32con, win32event
from cbb_refresh_verify import residual_sessions as sessions
process = dict(row(10, 'C:/library/A.prj'), scope_confirmed=True,
created_handle='creation', image='C:/Mentor/iCDBProjectBackup.exe',
native_activity={'status': 'IDLE'}, **OWNERSHIP)
monkeypatch.setattr(sessions, '_process_handle', lambda *a, **kw: nullcontext(123))
monkeypatch.setattr(sessions, '_handle_identity', lambda _: {k:process[k] for k in ('created_handle','image')})
monkeypatch.setattr(sessions, '_force_ownership', lambda *a: dict(OWNERSHIP))
monkeypatch.setattr(win32event, 'WaitForSingleObject', lambda *a: win32con.WAIT_TIMEOUT)
monkeypatch.setattr(sessions, '_process_windows', lambda _: {10: [
{'hwnd': 100, 'class': 'Afx:main', 'title': 'iCDB Project Backup - A',
'enabled': True, 'children': [], 'output': output, 'desktop': 'CbbRepair_A'}]})
monkeypatch.setattr(win32api, 'TerminateProcess', lambda *a: pytest.fail('interrupted Backup/Repair'))
result = sessions._force_close(process)
assert result['release_status'] == 'WAITING'
assert result['native_activity']['status'] in ('ACTIVE', 'UNCONFIRMED')
def test_inspection_exposes_private_desktop_and_disables_force_for_active_backup(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library = tmp_path/'library/lib.lmc'; library.parent.mkdir(); library.touch()
process = row(10, library.parent/'ReusableBlocksLP/A/Work/A.prj')
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process])
monkeypatch.setattr(sessions, '_process_identity', lambda r:
dict(created_handle='creation', image=r['executable'], **OWNERSHIP))
monkeypatch.setattr(sessions, '_process_windows', lambda _: {10:[
{'hwnd':100,'class':'Afx:main','title':'iCDB Project Backup - A','enabled':True,
'children':[],'output':'Repairing project','desktop':'CbbRepair_A'}]})
preview = sessions.inspect_residual_sessions(library)['sessions'][0]
assert preview['force_allowed'] is False
assert preview['desktops'] == ['CbbRepair_A']
assert preview['native_activity']['status'] == 'ACTIVE'
def test_saved_prompt_from_private_desktop_remains_actionable():
from cbb_refresh_verify.residual_sessions import _save_question
prompt = _save_question([{'hwnd':100,'class':'#32770','title':'Expedition PCB',
'desktop':'CbbVerify_A','children':[{'class':'Static','text':'Save changes to modified design?'},
*[{'class':'Button','id':code,'hwnd':code,'enabled':True} for code in (6,7,2)]]}])
assert prompt['desktop'] == 'CbbVerify_A' and set(prompt['buttons']) == {6,7,2}
def test_native_cancel_requires_same_current_control_and_exact_owned_process(monkeypatch):
import win32con, win32event, win32gui, win32process
from cbb_refresh_verify import residual_sessions as sessions
process = dict(row(10, 'C:/library/A.prj'), scope_confirmed=True,
created_handle='creation', image='C:/Mentor/iCDBProjectBackup.exe', **OWNERSHIP)
window = {'hwnd':100,'class':'Afx:main','title':'iCDB Project Backup - A','enabled':True,
'output':'Backing up project','desktop':'CbbRepair_A',
'children':[{'class':'Button','id':2,'text':'Cancel','enabled':True,'hwnd':102}]}
monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process])
monkeypatch.setattr(sessions, '_process_handle', lambda *a,**kw: nullcontext(123))
monkeypatch.setattr(sessions, '_handle_identity', lambda _: {k:process[k] for k in ('created_handle','image')})
monkeypatch.setattr(sessions, '_force_ownership', lambda *a: dict(OWNERSHIP))
monkeypatch.setattr(sessions, '_process_windows', lambda _: {10:[window]})
monkeypatch.setattr(sessions, '_window_desktop', lambda *args, **kwargs: nullcontext(None))
monkeypatch.setattr(win32event, 'WaitForSingleObject', lambda *a: win32con.WAIT_TIMEOUT)
monkeypatch.setattr(win32process, 'GetWindowThreadProcessId', lambda _: (1,10))
clicked=[]; monkeypatch.setattr(win32gui, 'PostMessage', lambda *a: clicked.append(a))
process['cancel_prompt']={'hwnd':100,'button':dict(window['children'][0]),
'title':window['title'],'desktop':'CbbRepair_A'}
result = sessions._request_native_cancel(process)
assert result['release_status'] == 'WAITING' and clicked == [(102, win32con.BM_CLICK, 0, 0)]
window['children'][0]['text'] = 'Restore'
with pytest.raises(ValueError, match='取消'):
sessions._request_native_cancel(process)
assert len(clicked)==1
def test_ui_reports_missing_evidence_but_propagates_valid_library_release(qtbot, tmp_path, monkeypatch):
from cbb_refresh_verify import library_lock
from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog
library = tmp_path/'lib.lmc'
monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda *_:
{'library':str(library),'sessions':[]})
proof = {'status':'RELEASE_CONFIRMED','library':str(library)}
monkeypatch.setattr(library_lock, 'release_residual_sessions', lambda *a,**kw:
{'status':'PARTIAL','sessions':[],'proof':proof,'evidence_error':'disk full'})
dialog = ResidualReleaseDialog(library, tmp_path/'evidence'); qtbot.addWidget(dialog)
released = []; dialog.released.connect(released.append)
qtbot.waitUntil(lambda: not dialog.busy)
dialog.confirm_button.click(); qtbot.waitUntil(lambda: not dialog.busy)
assert released == [proof]
assert '记录' in dialog.message.text() and 'disk full' in dialog.message.text()
def test_ui_native_cancel_is_explicit_and_details_are_readable(qtbot, tmp_path, monkeypatch):
from PySide6.QtWidgets import QMessageBox
from cbb_refresh_verify import library_lock, residual_sessions
from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog
library = tmp_path/'lib.lmc'
process = {'name':'iCDBProjectBackup.exe','pid':10,'detail':'备份进行中',
'image':'C:/Mentor/iCDBProjectBackup.exe','desktops':['CbbRepair_A'],
'native_activity':{'status':'ACTIVE','detail':'正在备份'},'cancel_prompt':{'hwnd':100},
'windows':[{'title':'iCDB Project Backup - A','output':'Backing up project','children':[]}]}
monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda *_:
{'library':str(library),'sessions':[process]})
calls=[]
monkeypatch.setattr(residual_sessions,'request_native_cancel',lambda *a,**kw:
calls.append(a[0]) or {'status':'PARTIAL','sessions':[{'detail':'已请求取消'}]})
dialog=ResidualReleaseDialog(library,tmp_path/'evidence');qtbot.addWidget(dialog)
qtbot.waitUntil(lambda:not dialog.busy)
assert dialog.cancel_native_button.isEnabled() and not dialog.force_button.isEnabled()
dialog.details_button.click()
assert 'Backing up project' in dialog.native_details.detailedText()
assert 'CbbRepair_A' in dialog.native_details.detailedText()
dialog.native_details.close()
monkeypatch.setattr(timed_prompt,'question',lambda *a:QMessageBox.No)
dialog.cancel_native_button.click();assert calls==[]
monkeypatch.setattr(timed_prompt,'question',lambda *a:QMessageBox.Yes)
dialog.cancel_native_button.click();qtbot.waitUntil(lambda:not dialog.busy)
assert calls==[process]
def test_force_can_resume_after_backup_finishes_and_preview_is_refreshed(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library=tmp_path/'library/lib.lmc';library.parent.mkdir();library.touch()
process=row(10,library.parent/'ReusableBlocksLP/A/Work/A.prj')
monkeypatch.setattr(sessions,'query_process_snapshot',lambda:[process])
monkeypatch.setattr(sessions,'_process_identity',lambda r:
dict(created_handle='creation',image=r['executable'],**OWNERSHIP))
window={'hwnd':100,'class':'Afx:main','title':'iCDB Project Backup - A','enabled':True,
'children':[],'output':'Repairing project'}
monkeypatch.setattr(sessions,'_process_windows',lambda _:{10:[window]})
assert not sessions.inspect_residual_sessions(library)['sessions'][0]['force_allowed']
window['output']+='\nBackup information loaded correctly.'
assert sessions.inspect_residual_sessions(library)['sessions'][0]['force_allowed']
def test_native_cancel_records_consent_before_sending_any_message(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library=tmp_path/'library/lib.lmc';library.parent.mkdir();library.touch()
process=dict(row(10,library.parent/'ReusableBlocksLP/A/Work/A.prj'),
scope_confirmed=True,cancel_prompt={'hwnd':100})
evidence=tmp_path/'evidence'
monkeypatch.setattr(sessions,'query_process_snapshot',lambda:[process])
monkeypatch.setattr(sessions,'_process_windows',lambda _:{})
def cancel(actual, **kwargs):
record=json.loads(next(evidence.glob('sessions-*/consent.json')).read_text('utf-8'))
assert record['mode']=='cancel_native' and record['sessions'][0]['pid']==actual['pid']
return {'release_status':'WAITING','detail':'cancel requested'}
monkeypatch.setattr(sessions,'_request_native_cancel',cancel)
result=sessions.request_native_cancel(process,library,evidence)
assert result['cancel_native'] and Path(result['consent_path']).is_file()
assert result['sessions'][0]['detail']=='cancel requested'
def test_missing_initial_checkpoint_prevents_all_close_actions(tmp_path, monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library=tmp_path/'library/lib.lmc';library.parent.mkdir();library.touch()
process=dict(row(10,library.parent/'A.prj'),scope_confirmed=True)
original=Path.open
def denied(path,*args,**kwargs):
if path.name=='result.pending':raise PermissionError('no storage')
return original(path,*args,**kwargs)
monkeypatch.setattr(Path,'open',denied)
monkeypatch.setattr(sessions,'_request_close',lambda *a,**kw:pytest.fail('unrecorded close'))
result=sessions._release_residual_sessions({'library':str(library),'sessions':[process]},tmp_path/'evidence')
assert result['status']=='PARTIAL' and result['sessions'][0]['release_status']=='NOT_STARTED'
def test_native_cancel_completion_propagates_actual_release_to_parent(qtbot,tmp_path,monkeypatch):
from PySide6.QtWidgets import QMessageBox
from cbb_refresh_verify import library_lock,residual_sessions
from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog
library=tmp_path/'lib.lmc'
process={'name':'iCDBProjectBackup.exe','pid':10,'cancel_prompt':{'hwnd':100}}
monkeypatch.setattr(library_lock,'inspect_residual_sessions',lambda *_:
{'library':str(library),'sessions':[process]})
proof={'status':'RELEASE_CONFIRMED','library':str(library)}
monkeypatch.setattr(residual_sessions,'request_native_cancel',lambda *a,**kw:
{'status':'RELEASE_CONFIRMED','sessions':[{**process,'release_status':'RELEASED'}],'proof':proof})
monkeypatch.setattr(timed_prompt,'question',lambda *a:QMessageBox.Yes)
dialog=ResidualReleaseDialog(library,tmp_path/'evidence');qtbot.addWidget(dialog)
released=[];dialog.released.connect(released.append)
qtbot.waitUntil(lambda:not dialog.busy)
dialog.cancel_native_button.click();qtbot.waitUntil(lambda:not dialog.busy)
assert released==[proof] and dialog.plan is None
def test_interruption_after_request_is_not_recorded_as_never_started(tmp_path,monkeypatch):
from cbb_refresh_verify import residual_sessions as sessions
library=tmp_path/'library/lib.lmc';library.parent.mkdir();library.touch()
process=dict(row(10,library.parent/'A.prj'),scope_confirmed=True)
evidence=tmp_path/'evidence'
monkeypatch.setattr(sessions,'query_process_snapshot',lambda:[process])
observed=[]
def interrupted(*a,**kw):
record=json.loads(next(evidence.glob('sessions-*/result.json')).read_text('utf-8'))
observed.append(record['sessions'][0]['release_status'])
raise KeyboardInterrupt()
monkeypatch.setattr(sessions,'_request_close',interrupted)
with pytest.raises(KeyboardInterrupt):
sessions._release_residual_sessions({'library':str(library),'sessions':[process]},evidence)
assert observed==['REQUESTING']
saved=json.loads(next(evidence.glob('sessions-*/result.json')).read_text('utf-8'))
assert saved['sessions'][0]['release_status']=='REQUESTING' and saved['status']=='PARTIAL'
def test_stop_during_native_activity_read_prevents_force_termination(monkeypatch):
from threading import Event
import win32api,win32con,win32event
from cbb_refresh_verify import residual_sessions as sessions
process=dict(row(10,'C:/library/A.prj',name='ExpeditionPCB.exe'),scope_confirmed=True,
created_handle='creation',image='C:/Mentor/ExpeditionPCB.exe',**OWNERSHIP)
stop=Event()
monkeypatch.setattr(sessions,'_process_handle',lambda *a,**kw:nullcontext(123))
monkeypatch.setattr(sessions,'_handle_identity',lambda _:{k:process[k] for k in ('created_handle','image')})
monkeypatch.setattr(sessions,'_force_ownership',lambda *a:dict(OWNERSHIP))
monkeypatch.setattr(win32event,'WaitForSingleObject',lambda *a:win32con.WAIT_TIMEOUT)
def windows(*args):stop.set();return {10:[]}
monkeypatch.setattr(sessions,'_process_windows',windows)
monkeypatch.setattr(win32api,'TerminateProcess',lambda *a:pytest.fail('force continued after stop'))
assert sessions._force_close(process,stop=stop)['release_status']=='CANCELLED'
def test_gui_release_proof_comparison_does_not_probe_network_filesystem(qtbot,tmp_path,monkeypatch):
from cbb_refresh_verify import library_lock
from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog
library=tmp_path/'lib.lmc'
monkeypatch.setattr(library_lock,'inspect_residual_sessions',lambda *_:
{'library':str(library),'sessions':[]})
dialog=ResidualReleaseDialog(library,tmp_path/'evidence');qtbot.addWidget(dialog)
qtbot.waitUntil(lambda:not dialog.busy)
with monkeypatch.context() as guard:
guard.setattr(Path,'resolve',lambda *a,**kw:pytest.fail('GUI tried filesystem resolution'))
assert dialog._accept_release_proof({'sessions':[],'proof':{
'status':'RELEASE_CONFIRMED','library':str(library)}})