305 lines
18 KiB
Python
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)}})
|