Files
cbb-refresh-verify-795/tests/test_management_supervision.py
T

147 lines
6.6 KiB
Python

from dataclasses import replace
import json
import os
from pathlib import Path
from threading import Event
import pytest
from cbb_refresh_verify import native_management as native
from cbb_refresh_verify.session_record import process_identity
from test_management import setup, execute
@pytest.mark.parametrize('operation', ['catalog', 'add', 'remove'])
@pytest.mark.parametrize('reason', ['cancelled', 'parent_gone', 'identity_changed'])
def test_management_worker_checks_stop_before_any_native_route(tmp_path, monkeypatch, operation, reason):
cancel = tmp_path/'cancel.signal'
identity = process_identity(os.getpid())
if reason == 'cancelled':
cancel.touch()
if reason == 'identity_changed':
identity['created_handle'] = 'old'
job = dict(operation=operation, library=str(tmp_path/'lib.lmc'), desktop='CbbManagement_Test',
supervisor_pid=-1 if reason == 'parent_gone' else os.getpid(),
supervisor_identity=identity, cancel_signal=str(cancel), operation_id='test-management')
request = tmp_path/'request.json'
request.write_text(json.dumps(job))
monkeypatch.setattr(native, '_current_desktop', lambda: (None, job['desktop']))
monkeypatch.setattr(native, '_catalog_native', lambda *a: pytest.fail('unsupervised native route'))
monkeypatch.setattr(native.subprocess, 'Popen', lambda *a, **kw: pytest.fail('unsupervised remove'))
assert native.management_worker_main(request) == 2
result = json.loads((tmp_path/'result.json').read_text())
assert not result['success']
assert result['safe_to_continue'] is True
assert 'CANCELLED' in result['detail'] or '监督器' in result['detail']
def test_cancel_after_remove_stops_update_before_catalog_and_add(setup):
req, adapter, source = setup
stop = Event()
remove = adapter.remove
def stop_after_remove(*args):
result = remove(*args)
stop.set()
return result
adapter.remove = stop_after_remove
result = execute(replace(req, operation='update', source=source), adapter, stop=stop)
assert adapter.calls == ['remove']
assert result.status == 'RECOVERY_REQUIRED'
assert result.safe_to_continue is True
checkpoint = json.loads(result.evidence_path.read_text('utf-8'))
assert any(item['stage'] == 'native_remove' for item in checkpoint['history'])
def test_cancel_before_catalog_does_not_launch_native(setup):
req, adapter, _ = setup
stop = Event()
stop.set()
adapter.catalog = lambda *a: pytest.fail('catalog after cancellation')
result = execute(req, adapter, stop=stop)
assert result.status == 'CANCELLED'
assert result.safe_to_continue is True
def test_real_management_worker_parent_loss_waits_for_native_boundary(tmp_path):
import subprocess
import sys
import time
from cbb_refresh_verify.session_record import write_session_record
supervisor = subprocess.Popen([sys.executable, '-c', 'import time;time.sleep(30)'])
request, script = tmp_path/'request.json', tmp_path/'worker.py'
gate, cancel, started, continued = [tmp_path/name for name in ('gate', 'cancel', 'started', 'continued')]
job = dict(operation='catalog', library=str(tmp_path/'lib.lmc'), desktop='CbbManagement_test',
supervisor_pid=supervisor.pid, supervisor_identity=process_identity(supervisor.pid),
cancel_signal=str(cancel), start_gate=str(gate), operation_id='real-management',
session_record_path=str(tmp_path/'session.json'))
request.write_text(json.dumps(job))
script.write_text('import time,sys\nfrom pathlib import Path\n'
'from cbb_refresh_verify import native_management as n\n'
'n._current_desktop=lambda:(None,"CbbManagement_test")\n'
'def native_call(job,root):\n'
f' Path({str(started)!r}).touch()\n'
' time.sleep(1.5)\n'
' try: n._require_management_continuation(job,root)\n'
' except RuntimeError as e: return dict(success=False,safe_to_continue=True,detail=str(e))\n'
f' Path({str(continued)!r}).touch()\n'
' return dict(success=True,safe_to_continue=True)\n'
'n._catalog_native=native_call\n'
f'sys.exit(n.management_worker_main({str(request)!r}))\n')
worker = subprocess.Popen([sys.executable, str(script)])
try:
write_session_record(tmp_path/'session.json', dict(operation_id='real-management',
library=job['library'], processes=[{'role': 'worker', **process_identity(worker.pid)}]))
gate.touch()
deadline = time.monotonic()+8
while not started.exists() and time.monotonic()<deadline:
time.sleep(.02)
assert started.exists()
supervisor.terminate(); supervisor.wait(5)
deadline = time.monotonic()+1
while not cancel.exists() and time.monotonic()<deadline:
time.sleep(.02)
assert cancel.exists() and worker.poll() is None
assert worker.wait(5) == 2
assert not continued.exists()
assert (tmp_path/'supervisor-lost.json').is_file()
assert json.loads((tmp_path/'result.json').read_text())['safe_to_continue'] is True
finally:
for process in (worker, supervisor):
if process.poll() is None:
process.terminate()
process.wait(5)
def test_remove_timeout_keeps_worker_observing_until_native_returns(tmp_path, monkeypatch):
from types import SimpleNamespace
from threading import Thread
entered, release, done = Event(), Event(), Event()
job = tmp_path/'request.json'
job.write_text(json.dumps(dict(operation='remove', library=str(tmp_path/'lib.lmc'),
desktop='CbbManagement_test', mentor_home=str(tmp_path), name='A',
partition='Logical-Physical', timeout_seconds=0, supervisor_pid=os.getpid())))
monkeypatch.setattr(native, '_current_desktop', lambda: (None, 'CbbManagement_test'))
monkeypatch.setattr(native.NativeManagementAdapter, 'capabilities',
lambda _: {'remove': SimpleNamespace(supported=True)})
def wait(timeout):
entered.set()
if not release.wait(.05):
raise native.subprocess.TimeoutExpired('fake native remove', timeout)
return 0
monkeypatch.setattr(native.subprocess, 'Popen', lambda *a, **kw: SimpleNamespace(pid=123456, wait=wait))
def run():
try:
native.management_worker_main(job)
finally:
done.set()
thread = Thread(target=run)
thread.start()
try:
assert entered.wait(3)
assert not done.wait(.2), 'native timeout abandoned the still-running owner'
finally:
release.set()
thread.join(3)
assert done.is_set()
assert json.loads((tmp_path/'result.json').read_text())['safe_to_continue'] is True