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

408 lines
23 KiB
Python

"""Issue 15 recovery entry regressions. Native boundaries never launch Mentor."""
from contextlib import contextmanager
import json
import os
from pathlib import Path
from types import SimpleNamespace
import pytest
@pytest.fixture(autouse=True)
def no_real_owner_probe(monkeypatch):
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda names: [])
def test_ordinary_worker_aligns_both_bound_projects_and_retains_each_original(tmp_path, monkeypatch):
from test_verify_worker_stability import exercise_worker
from cbb_refresh_verify import mentor_adapter as adapter
job, events, execute = exercise_worker(tmp_path, monkeypatch)
main = Path(job['project']); aux = Path(job['pcb']).parent/'pcb.prj'
original_main = b'KEY CentralLibrary "old-main.lmc"\r\n#\x81\x40\r\n'
original_aux = b'\xff\xfe'+ 'KEY CentralLibrary "old-pcb.lmc"\r\n'.encode('utf-16-le')
main.write_bytes(original_main); aux.write_bytes(original_aux)
assert execute()['status'] == 'PASS'
from cbb_refresh_verify.backup_recovery import _project_text
for path in (main, aux):
import re
reference = re.search(r'KEY CentralLibrary "([^"]+)"', _project_text(path))[1]
assert (path.parent/reference).resolve() == Path(job['lmc_file']).resolve()
saved = [p.read_bytes() for p in (Path(job['root'])/'diagnostics').rglob('*.before-central-library')]
assert original_main in saved and original_aux in saved
def test_ordinary_legacy_binding_never_rewrites_template(tmp_path, monkeypatch):
from test_verify_worker_stability import exercise_worker
job, _, execute = exercise_worker(tmp_path, monkeypatch)
main = Path(job['project']); pcb = Path(job['pcb'])
main.write_text('KEY CentralLibrary "old.lmc"\n')
pcb.write_text('KEY ProjectFile "../CBB.prj"\n')
template = pcb.parent/'template.prj'; template.write_text('KEY CentralLibrary "do-not-touch.lmc"\n')
original = template.read_bytes()
assert execute()['status'] == 'PASS'
assert template.read_bytes() == original
assert 'old.lmc' not in main.read_text()
def inconsistency(database):
return (f'Project database [{database}] is inconsistent. It has been manually copied while the iCDB Server was running. '
"Please use iCDB Project Backup 'Repair project' functionality to fix this issue.")
def test_current_inconsistency_has_structured_database_and_old_error_is_not_reused(tmp_path):
from cbb_refresh_verify import icdb_recovery as recovery, mentor_adapter as adapter
source = tmp_path/'LogFiles/PCBLogFile.txt'; source.parent.mkdir()
db = tmp_path/'database'; message = inconsistency(db)
source.write_text(message+'\n')
baseline = recovery.snapshot_log(source)
assert recovery.read_log_failure(source, baseline)[1] is None
source.write_text('new header\n'+message+'\n')
assert recovery.read_log_failure(source, baseline)[1] is None
baseline = recovery.snapshot_log(source)
with source.open('a') as stream: stream.write(message+'\n')
text, record = recovery.read_log_failure(source, baseline)
assert record['database_path'] == str(db) and record['scope'] == 'project'
assert record['kind'] == 'database_inconsistent'
detail = adapter.pcb_log_reports_missing_server(tmp_path/'CBB.pcb', offset=baseline)
assert 'ICDB_REPAIR_REQUIRED' in detail and str(db) in detail and '未修复' in detail
def test_manual_repair_selects_diagnosed_bound_database_without_layout_or_healthy_header(tmp_path):
from test_native_backup import project_fixture
from cbb_refresh_verify import native_backup as native
request, main = project_fixture(tmp_path)
pcb = main.parent/'PCB/Block.pcb'; pcb.parent.mkdir()
pcb.write_text('KEY ProjectFile "../Block.prj"\n')
aux = pcb.parent/'pcb.prj'; aux.write_text('KEY iCDBDir "database"\n')
for prj in (main, aux):
(prj.parent/'database').mkdir(); (prj.parent/'database/icdb.dat').write_bytes(b'not-a-healthy-header')
assert native.native_backup_target(request, mode='repair')[0] == main
assert native.native_backup_target(request, mode='repair', target_database=aux.parent/'database')[0] == aux
with pytest.raises(ValueError, match='TARGET'):
native.native_backup_target(request, mode='repair', target_database=tmp_path/'foreign')
def test_versions_launcher_rechecks_parent_retained_lease_and_persists_before_gate(tmp_path, monkeypatch):
import subprocess, sys
from test_native_backup import project_fixture
from cbb_refresh_verify import native_backup as native, library_lock, session_record
request, project = project_fixture(tmp_path)
monkeypatch.setattr(native, 'native_backup_executable', lambda *_: tmp_path/'native.exe')
calls = []
monkeypatch.setattr(library_lock, 'recheck_previous_release', lambda *a, **k: calls.append('recheck'))
monkeypatch.setattr(session_record, 'process_identity', lambda pid: dict(pid=pid, created='now', executable='python', owner='test'))
child = subprocess.Popen([sys.executable,'-c','input()'],stdin=subprocess.PIPE,text=True)
def spawn(command, **kw):
job = json.loads(Path(command[-1]).read_text())
assert calls == ['recheck'] and not Path(job['start_gate']).exists()
calls.append('spawn')
return child
monkeypatch.setattr(native.subprocess, 'Popen', spawn)
try:
session = native.launch_native_backup(request, mode='repair')
finally:
child.communicate('\n',timeout=5)
record = json.loads(session.job.read_text())
assert Path(record['start_gate']).is_file()
assert Path(record['session_record_path']).is_file()
assert session.mode == 'repair' and session.database == project.parent/'database'
assert session.operation_id == record['operation_id']
assert record['automatic_repair'] is False
@pytest.mark.parametrize('failure', ['spawn', 'registration'])
def test_backup_failure_leaves_start_gate_closed(tmp_path, monkeypatch, failure):
from test_native_backup import project_fixture
from cbb_refresh_verify import native_backup as native, session_record
request, _ = project_fixture(tmp_path)
monkeypatch.setattr(native, 'native_backup_executable', lambda *_: tmp_path/'native.exe')
def spawn(*a, **k):
if failure == 'spawn': raise OSError('start failed')
return SimpleNamespace(pid=123, poll=lambda: None)
monkeypatch.setattr(native.subprocess, 'Popen', spawn)
monkeypatch.setattr(session_record, 'register_worker_session', lambda *a: (_ for _ in ()).throw(OSError('register failed')))
with pytest.raises(OSError): native.launch_native_backup(request)
job = next(request.evidence_dir.glob('native-backup-*/request.json'))
record = json.loads(job.read_text())
assert not Path(record['start_gate']).exists()
assert Path(record['cancel_signal']).exists()
def test_changed_prj_bytes_refused_before_recovery_tool_dispatch(tmp_path, monkeypatch):
import hashlib
from test_native_backup import project_fixture
from cbb_refresh_verify import native_backup as native
request, project = project_fixture(tmp_path)
job = tmp_path/'request.json'
record = dict(library=str(request.lmc_file), block=request.block_name, project=str(project),
project_sha256=hashlib.sha256(project.read_bytes()).hexdigest())
job.write_text(json.dumps(record))
project.write_text(project.read_text()+'# changed identity\n')
monkeypatch.setattr(native, 'native_backup_executable', lambda *_: tmp_path/'native.exe')
assert native.native_backup_worker_main(job, process_factory=lambda *a: pytest.fail('changed PRJ dispatched')) == 1
assert '身份' in json.loads(job.with_name('result.json').read_text('utf-8'))['detail']
def test_real_parent_retained_sidecar_is_reconciled_before_child_acquires_it_and_reopens(tmp_path, monkeypatch):
import subprocess, sys
from test_native_backup import project_fixture
from cbb_refresh_verify import native_backup as native, library_lock as locks
from cbb_refresh_verify.file_probe import hold_release_files
request, _ = project_fixture(tmp_path)
with locks.LibraryLock(request.lmc_file, safe_to_release=lambda: False, block_name='Block') as retained:
pass
@contextmanager
def proof(library, **kwargs):
with hold_release_files(library, (library.parent/'ReusableBlocksLP/Block/Work',)) as files:
yield {**files, 'native_owners': []}
monkeypatch.setattr(locks, '_prove_library_released', proof)
monkeypatch.setattr(native, 'native_backup_executable', lambda *_: tmp_path/'not-launched.exe')
popen = subprocess.Popen
script = (
'import json,sys\nfrom pathlib import Path\n'
'from cbb_refresh_verify.desktop_worker import run_native_worker\n'
'from cbb_refresh_verify.library_lock import LibraryLock\n'
'def action(path):\n'
' j=json.loads(Path(path).read_text())\n'
' with LibraryLock(j["library"],checkpoint=False):\n'
' Path(path).with_name("child-acquired").write_text("owned")\n'
' return 0\n'
'raise SystemExit(run_native_worker(action,sys.argv[1]))\n')
def spawn(command, **kwargs):
if '--native-backup-worker' in command:
assert not locks.has_retained_library(request.lmc_file)
return popen([sys.executable, '-c', script, command[-1]], **kwargs)
return popen(command, **kwargs)
monkeypatch.setattr(native.subprocess, 'Popen', spawn)
try:
for mode in ('versions', 'repair'):
session = native.launch_native_backup(request, mode=mode)
assert session.process.wait(10) == 0
assert session.job.with_name('child-acquired').read_text() == 'owned'
assert retained.path.is_file()
finally:
owner = locks._owners.pop(retained.key, None)
if owner: owner['handle'].Close()
def test_native_registration_failure_never_resumes_suspended_child(tmp_path):
import sys
from cbb_refresh_verify.native_backup import _NativeBackupProcess
marker = tmp_path/'must-not-run'
def refuse(process): raise OSError('required identity journal failed')
with pytest.raises(OSError, match='journal'):
_NativeBackupProcess([sys.executable, '-c', f'from pathlib import Path;Path({str(marker)!r}).touch()'],
tmp_path, before_resume=refuse)
assert not marker.exists()
def test_independent_backup_job_registration_retains_descendants_after_caller_handles_close(tmp_path):
import sys, time
from cbb_refresh_verify.native_backup import _NativeBackupProcess, _BackupJobWriter
script = tmp_path/'parent.py'; marker = tmp_path/'child.pid'
script.write_text('import subprocess,sys,time\nfrom pathlib import Path\n'
'p=subprocess.Popen([sys.executable,"-c","import time;time.sleep(1)"])\n'
f'Path({str(marker)!r}).write_text(str(p.pid))\ntime.sleep(.1)\n')
process = _NativeBackupProcess([sys.executable, str(script)], tmp_path)
registered = _BackupJobWriter(process.job)
try:
deadline = time.monotonic()+5
while process.poll() is None and time.monotonic()<deadline: time.sleep(.02)
assert marker.exists() and process.poll() == 0
process.close()
assert registered.poll() is None
while registered.poll() is None and time.monotonic()<deadline: time.sleep(.02)
assert registered.poll() == 0
finally:
if registered.job is not None: registered.job.Close()
def test_common_admission_refusal_publishes_bound_receipt_and_ui_can_reopen(qtbot, tmp_path, monkeypatch):
import subprocess,sys
from threading import Event, Thread
from test_native_backup import project_fixture
from test_ui_filters import load_window
from cbb_refresh_verify import native_backup as native, desktop_worker
request, _ = project_fixture(tmp_path)
monkeypatch.setattr(native, 'native_backup_executable', lambda *_: tmp_path/'native.exe')
# A cold observer reads kernel identity: poll=exited on pytest's live PID
# cannot represent a released worker. Use a real, harmless refused child.
invoke = tmp_path/'invoke-refusal.signal'
child = tmp_path/'refused_worker.py'
child.write_text('import sys,time\nfrom pathlib import Path\n'
f'gate=Path({str(invoke)!r})\ndeadline=time.monotonic()+10\n'
'while not gate.exists() and time.monotonic()<deadline:time.sleep(.01)\n'
'assert gate.exists()\n'
'from cbb_refresh_verify import native_backup\n'
'def forbidden(*args):raise AssertionError("refused action entered")\n'
'native_backup.native_backup_worker_main=forbidden\n'
'from cbb_refresh_verify.application import main\n'
'raise SystemExit(main(["--native-backup-worker",sys.argv[1]]))\n')
popen = subprocess.Popen
with monkeypatch.context() as launch:
launch.setattr(native.subprocess, 'Popen', lambda command, **kwargs:
popen([sys.executable,str(child),command[-1]], **kwargs))
session = native.launch_native_backup(request)
entered, release = Event(), Event()
monkeypatch.setattr(desktop_worker, '_automation_clients', [])
def held_writer():
with desktop_worker.worker_native_channel():
entered.set(); release.wait(10)
holder = Thread(target=held_writer); holder.start()
assert entered.wait(2)
try:
invoke.touch()
assert session.process.wait(timeout=8) == 1
finally:
release.set(); holder.join(3)
record = json.loads(session.job.with_name('result.json').read_text('utf-8'))
assert record['safe_to_continue'] is True and record['native_started'] is False
assert record['operation_id'] == json.loads(session.job.read_text('utf-8'))['operation_id']
assert record['worker_identity']['pid'] == session.process.pid != os.getpid()
launched = []
window = load_window(qtbot, tmp_path, monkeypatch,
native_backup_launcher=lambda req: (launched.append(req) or session),
status_refresher=lambda names, _: {name:'UNKNOWN' for name in names})
# Deliver the receipt to its actual library view; a foreign view must not
# receive an old session's status label after Task 4's callback isolation.
window.path_lease_factory = lambda path: SimpleNamespace(mentor_path=path, display_path=path,
drive='', remote_root='', close=lambda:None, retain_for_recovery=lambda:None)
window.lmc_edit.setText(str(session.library)); window.load_library()
qtbot.waitUntil(lambda:not window.busy)
session.block = 'Beta'; record['block'] = 'Beta'
session.job.with_name('result.json').write_text(json.dumps(record), encoding='utf-8')
window._native_backup_session = session
window._poll_native_backup(); qtbot.waitUntil(lambda: not window.busy)
assert window._native_backup_session is None
assert 'NATIVE_WRITER_ACTIVE' in window.status_label.text()
window.search_edit.setText('Beta'); window.select_visible_button.click()
window.open_native_backup(); qtbot.waitUntil(lambda: not window.busy)
assert len(launched) == 1
window._native_backup_session = None # The test adapter has no live native client.
def test_unbound_admission_refusal_cannot_claim_release(tmp_path, monkeypatch):
from cbb_refresh_verify import native_backup as native, desktop_worker
job = tmp_path/'request.json'
job.write_text(json.dumps(dict(library=str(tmp_path/'lib.lmc'), block='A', operation_id='foreign',
session_record_path=str(tmp_path/'session.json'), project=str(tmp_path/'A.prj'))))
monkeypatch.setattr(desktop_worker, 'run_native_worker', lambda *a, admission_state=None: (_ for _ in ()).throw(RuntimeError('refused')))
assert native.run_native_backup_worker(job) == 1
result = json.loads(job.with_name('result.json').read_text('utf-8'))
assert result['safe_to_continue'] is False
def test_legacy_unregistered_backup_job_cannot_enter_native_action(tmp_path, monkeypatch):
from cbb_refresh_verify import native_backup as native, desktop_worker
job = tmp_path/'request.json'
job.write_text(json.dumps(dict(library=str(tmp_path/'lib.lmc'), block='A', project=str(tmp_path/'A.prj'))))
monkeypatch.setattr(desktop_worker, '_automation_clients', [])
monkeypatch.setattr(native, 'native_backup_worker_main', lambda *a: pytest.fail('unregistered action entered'))
assert native.run_native_backup_worker(job) == 1
assert json.loads(job.with_name('result.json').read_text('utf-8'))['safe_to_continue'] is False
@pytest.mark.parametrize('owner_scope', ['target', 'unrelated'])
def test_recovery_entry_scopes_external_ownership_before_launch(tmp_path, monkeypatch, owner_scope):
from test_native_backup import project_fixture
from cbb_refresh_verify import native_backup as native, owner_probe
request, project = project_fixture(tmp_path)
job = tmp_path/'request.json'
job.write_text(json.dumps(dict(library=str(request.lmc_file), block=request.block_name,
project=str(project), mode='repair')))
monkeypatch.setattr(native, 'native_backup_executable', lambda *_: tmp_path/'native.exe')
external = project if owner_scope == 'target' else tmp_path/'other/Work/other.prj'
monkeypatch.setattr(owner_probe, 'query_owners', lambda names: [dict(pid=99999,
name='ExpeditionPCB.exe', command=f'ExpeditionPCB.exe "{external}"', executable='ExpeditionPCB.exe')])
def process(*args):
if owner_scope == 'target': pytest.fail('external target owner bypassed')
return SimpleNamespace(pid=456, poll=lambda: 0, session_pids=lambda: [], close=lambda: None)
assert native.native_backup_worker_main(job, process_factory=process) == (1 if owner_scope == 'target' else 0)
result = json.loads(job.with_name('result.json').read_text('utf-8'))
assert result['safe_to_continue'] is True
if owner_scope == 'target': assert 'OWNER_ACTIVE' in result['detail']
else: assert result['status'] == 'CLOSED'
@pytest.mark.parametrize('user_timeout', [5, 600])
def test_lm_menu_return_without_pcb_uses_dispatch_budget_and_closes_lm(tmp_path, monkeypatch, user_timeout):
from test_verify_worker_stability import exercise_worker
from cbb_refresh_verify import mentor_adapter as adapter, library_manager_verify as lm
job, events, execute = exercise_worker(tmp_path, monkeypatch)
job['native_lm_verify'] = True; job['timeout'] = user_timeout
(Path(job['pcb']).parent/'pcb.prj').write_text('KEY CentralLibrary "old.lmc"\n')
clock = [0.0]; closed = []
monkeypatch.setattr(adapter.time, 'monotonic', lambda: clock[0])
monkeypatch.setattr(adapter.time, 'sleep', lambda seconds: clock.__setitem__(0, clock[0]+seconds))
monkeypatch.setattr(adapter, 'select_reusable_circuit_worker', lambda *a, **k: None)
def launch(*args, **kw):
assert args[3] <= min(45, user_timeout)
return SimpleNamespace(process=SimpleNamespace(pid=123), close=lambda: closed.append(True))
monkeypatch.setattr(lm, 'launch_library_verify', launch)
with pytest.raises(RuntimeError, match='VERIFY_DISPATCH_FAILED'): execute()
assert clock[0] <= min(45, user_timeout)+1 and closed == [True]
def test_inconsistency_preserves_shared_database_scope():
from cbb_refresh_verify.icdb_recovery import parse_recovery_request
database = r'C:\\library\\SymbolLibs\\__ReusableBlocksSymb'
assert parse_recovery_request(inconsistency(database))['scope'] == 'central_library'
@pytest.mark.parametrize('case', ['not_in_use', 'repair_required', 'in_use', 'unconfirmed', 'wrong_target',
'no_identity', 'changed_address', 'changed_project', 'shared_address', 'exclusive'])
def test_explicit_continue_requires_exact_fresh_native_and_exclusive_proof(tmp_path, monkeypatch, case):
from test_native_repair import target_fixture
from test_native_occupancy import output
from cbb_refresh_verify import pcb_open_consent as consent, native_repair, owner_probe, session_record
from cbb_refresh_verify.verify_runner import preflight
request, _, target = target_fixture(tmp_path)
request.evidence_dir.mkdir()
project, pcb = preflight(request)
project.write_text('KEY PCBDesignPath "PCB/actual.pcb"\nKEY iCDBDir "database"\n')
pcb.write_text('KEY ProjectFile "../'+project.name+'"\n')
address = target.database/'cdbsvr/sAddress.adr'; address.parent.mkdir(); address.write_bytes(b'unchanged address')
if case == 'shared_address':
shared = request.lmc_file.parent/'SymbolLibs/__ReusableBlocksSymb/cdbsvr/sAddress.adr'
shared.parent.mkdir(parents=True); shared.write_bytes(b'unknown shared owner')
monkeypatch.setattr(owner_probe, 'query_process_snapshot', lambda: [])
calls = []
def inspect(inspected, root, **kwargs):
assert kwargs['inspection_only'] is True
calls.append(inspected)
record = dict(status='NOT_IN_USE', project=str(target.project), database=str(target.database),
native_pid=os.getpid(), native_identity=session_record.process_identity(os.getpid()),
inspection_only=True, repair_requested=False, repair_required=case == 'repair_required',
native_exit_code=0, release={'native_exited': True},
output=output(target.project, target.database, fault=case == 'repair_required'))
if case == 'in_use': record.update(status='IN_USE', output=output(target.project, target.database, busy=True))
if case == 'unconfirmed': record.update(status='UNCONFIRMED', output='not known')
if case == 'wrong_target': record['database'] = str(tmp_path/'foreign')
if case == 'no_identity': record.pop('native_identity')
if case == 'changed_address': address.write_bytes(b'new address')
if case == 'changed_project': project.write_text('KEY iCDBDir "another-db"\n')
return record
monkeypatch.setattr(native_repair, 'run_native_repair', inspect)
job = dict(root=str(request.evidence_dir), lmc_file=str(request.lmc_file),
block_name=request.block_name, project=str(project), pcb=str(pcb), operation_id='current-open')
held = None
if case == 'exclusive':
import win32con, win32file
held = win32file.CreateFile(str(target.database/'icdb.dat'), win32con.GENERIC_READ,
0, None, win32con.OPEN_EXISTING, 0, None)
try:
if case in ('not_in_use', 'repair_required'):
with consent.resource_guard(job, {os.getpid()}): pass
assert calls == [target]
evidence = json.loads((request.evidence_dir/'pcb-open-resource-proof.json').read_text())
assert evidence['operation_id'] == 'current-open'
assert evidence['repair_confirmed'] is False
else:
with pytest.raises((ValueError, OSError)):
with consent.resource_guard(job, {os.getpid()}): pass
finally:
if held is not None: held.Close()
if case not in ('shared_address', 'exclusive'):
assert calls == [target]
if case != 'changed_address': assert address.read_bytes() == b'unchanged address'