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

155 lines
8.3 KiB
Python

import json
from pathlib import Path
from threading import Event
import pytest
from cbb_refresh_verify import desktop_worker, session_record, verify_runner as runner
from cbb_refresh_verify.dialog_supervisor import DialogPollResult
from test_verify_runner import fixture, request, PORTS_OK
def worker_fixture(tmp_path, monkeypatch, *, exited=False):
fixture(tmp_path)
state = dict(waits=[], closed=False, observers=[], polling=False, polls=0)
stop = Event()
class Worker:
desktop=None; pid=700; companion_pids=[]; returncode=1 if exited else None
def __init__(self, command, name):
self.name=name
path=Path(command[-1]); state.update(path=path,job=json.loads(path.read_text()),worker=self)
self.session_record_path=path.with_name('session.json')
session_record.write_session_record(self.session_record_path, dict(
operation_id=state['job']['operation_id'],library=state['job']['library'],
block=state['job']['block']))
path.with_name('events.jsonl').write_text(json.dumps(dict(stage='pcb_worker_started',pcb_pid=901))+'\n')
path.with_name('outcome.json').write_text(json.dumps(dict(status='CANCELLED',safe_to_continue=False)))
def poll(self):return self.returncode
def request_stop(self):
assert not state['polling']
Path(state['job']['cancel_signal']).touch()
def native_write_pending(self):return True
def wait(self,timeout=5):
state['waits'].append(timeout)
if timeout <= 5:raise TimeoutError('native startup still closing')
self.returncode=1;return 1
def automation_release_state(self):return {'safe_to_continue':self.poll() is not None,'remaining_pids':[]}
def close(self):state['closed']=True
class Supervisor:
def poll(self,*args):
assert not state['observers']
state['polling']=True;state['polls']+=1;stop.set();state['polling']=False
return DialogPollResult()
monkeypatch.setattr(desktop_worker,'DesktopWorker',Worker)
monkeypatch.setattr(runner,'_cleanup_session_processes',lambda *a,**kw:
{'safe_to_continue':False,'remaining_pids':[901]})
monkeypatch.setattr(session_record,'handoff_session',lambda path,**kw:
state['observers'].append((path,kw,state['closed'])))
# Keep the task runner deterministic while exercising real supervisor ownership decisions.
monkeypatch.setattr('cbb_refresh_verify.operation_queue.hold_native_handoff',lambda *a:None)
return state,stop,lambda diagnostic:runner.run_verify(request(tmp_path,diagnostic_only=diagnostic),
port_check=PORTS_OK,stop=stop,dialog_supervisor_factory=lambda **kw:Supervisor())
@pytest.mark.parametrize('diagnostic',[True,False])
def test_diagnostic_cancel_yields_after_five_seconds_but_write_wait_is_unchanged(tmp_path,monkeypatch,diagnostic):
state,stop,run=worker_fixture(tmp_path,monkeypatch)
assert run(diagnostic).status=='CANCELLED'
assert state['waits']==([5] if diagnostic else [5,115])
assert state['observers'] and state['observers'][0][1]['process'] is state['worker']
assert not state['observers'][0][2] and not state['closed']
assert state['polls']==1
def test_exited_worker_with_live_native_clients_keeps_ownership_for_observer(tmp_path,monkeypatch):
state,stop,run=worker_fixture(tmp_path,monkeypatch,exited=True)
result=run(True)
assert result.status=='CANCELLED' and not result.safe_to_continue
assert len(state['observers'])==1, 'worker exit must not orphan the still-live registered native client'
path,options,already_closed=state['observers'][0]
assert path==state['worker'].session_record_path
assert options['process'] is state['worker'] and not already_closed and not state['closed']
original=json.loads(state['path'].with_name('result.json').read_text())
assert original['status']=='CANCELLED' and not original['safe_to_continue']
def test_failed_observer_registration_preserves_original_cancelled_result_and_handle(tmp_path,monkeypatch):
state,stop,run=worker_fixture(tmp_path,monkeypatch,exited=True)
def fail(*args,**kwargs):raise OSError('observation journal unavailable')
monkeypatch.setattr(session_record,'handoff_session',fail)
result=run(True)
assert result.status=='CANCELLED' and not result.safe_to_continue
assert not state['closed']
def test_missing_operation_identity_cannot_promote_cold_observation(tmp_path,monkeypatch):
from types import SimpleNamespace
path=tmp_path/'session.json';path.write_text('{invalid')
entered,finish=Event(),Event();modes=[]
def observe(*args,**kwargs):
mode=kwargs['observe_only'];modes.append(mode() if callable(mode) else mode)
entered.set();assert finish.wait(3)
return dict(status='UNCONFIRMED',operation_id=None)
monkeypatch.setattr(session_record,'observe_retained_session',observe)
owner=SimpleNamespace(cbb_library=str(tmp_path/'lib.lmc'),poll=lambda:0,close=lambda:None)
thread=None
try:
session_record.handoff_session(path,evidence_root=tmp_path,process=owner,observe_only=True)
assert entered.wait(2)
thread=session_record._observers[str(path.absolute()).casefold()][0]
assert modes==[True]
finally:
finish.set()
if thread:thread.join(3)
@pytest.mark.parametrize('cold_observer',[False,True])
def test_natural_native_exit_gets_fresh_release_and_admits_waiting_scope_without_click(tmp_path,monkeypatch,cold_observer):
import subprocess,sys,time
from concurrent.futures import ThreadPoolExecutor
from types import SimpleNamespace
from cbb_refresh_verify import library_lock
from cbb_refresh_verify.operation_queue import NativeQueue,BatchTaskContext
from test_issue15_resource_release import library_file,cleanup
library=library_file(tmp_path)
gate=tmp_path/'native-exit'
native=subprocess.Popen([sys.executable,'-c',
'from pathlib import Path; import time,sys\nwhile not Path(sys.argv[1]).exists(): time.sleep(.02)',str(gate)])
evidence=tmp_path/'evidence';evidence.mkdir();path=evidence/'session.json'
session_record.write_session_record(path,dict(operation_id='cancelled-owned',operation='verify',
library=str(library),block='A',processes=[dict(role='native',**session_record.process_identity(native.pid))]))
original=evidence/'result.json';original.write_text('{"status":"CANCELLED","safe_to_continue":false}')
before=original.read_bytes()
with library_lock.LibraryLock(library,block_name='A',safe_to_release=lambda:False) as lease:pass
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners',lambda *a,**kw:[])
active=Event();stop=Event();closed=[]
owner=SimpleNamespace(pid=700,poll=lambda:0,close=lambda:closed.append(native.poll()))
thread=None
try:
session_record.handoff_session(path,evidence_root=evidence,process=owner,stop=stop,observe_only=cold_observer,
progress=lambda state:active.set() if state['status']=='ACTIVE' else None)
assert active.wait(3) and not closed
key=str(path.absolute()).casefold()
thread=session_record._observers[key][0]
if cold_observer:
session_record.handoff_session(path,evidence_root=evidence,observe_only=False)
assert session_record._observers[key][0] is thread
assert not session_record.library_available(library)
queue=NativeQueue()
def admitted():
with library_lock.LibraryLock(library,checkpoint=False):return 'fresh admission'
with ThreadPoolExecutor(1) as pool:
future=pool.submit(queue.run,admitted,context=BatchTaskContext(str(library)),stop=stop)
time.sleep(.15);assert not future.done()
gate.touch();native.wait(5)
assert future.result(8)=='fresh admission'
thread.join(3)
assert not thread.is_alive() and closed==[0]
observations=[json.loads(p.read_text()) for p in evidence.glob('observation-*.json')]
assert any(o.get('status')=='RELEASED' and o['release_proof']['proof_block_name']=='A' for o in observations)
assert original.read_bytes()==before
finally:
gate.touch();native.wait(5);stop.set()
if thread:thread.join(3)
cleanup(lease)