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

246 lines
14 KiB
Python

"""Explicit maintenance for preexisting advertisements; native writes forbidden."""
from dataclasses import replace
from contextlib import contextmanager
import json
import os
from pathlib import Path
from types import SimpleNamespace
import pytest
@pytest.fixture(autouse=True)
def no_native_launch(monkeypatch):
import subprocess, win32process, win32com.client
import cbb_refresh_verify.desktop_worker as desktop
def forbidden(*a, **k): raise AssertionError('No native launch allowed in maintenance tests')
monkeypatch.setattr(subprocess, 'Popen', forbidden)
monkeypatch.setattr(win32process, 'CreateProcess', forbidden)
monkeypatch.setattr(win32com.client, 'Dispatch', forbidden)
monkeypatch.setattr(win32com.client, 'DispatchEx', forbidden)
monkeypatch.setattr(desktop, 'DesktopWorker', forbidden)
@pytest.fixture
def case(tmp_path, monkeypatch):
from cbb_refresh_verify.verify_runner import VerifyRequest
import cbb_refresh_verify.maintenance_entry as entry
library = tmp_path/'library/mentor.lmc'; library.parent.mkdir(); library.write_bytes(b'library')
work = library.parent/'ReusableBlocksLP/IP101GR/Work'
(work/'database/cdbsvr').mkdir(parents=True)
(work/'database/icdb.dat').write_bytes(b'schematic')
address = work/'database/cdbsvr/sAddress.adr'; address.write_bytes(b'old server address - preserved')
(work/'PCB/Layout').mkdir(parents=True)
(work/'PCB/Layout/LayoutDB.lyt').write_bytes(b'layout')
project = work/'IP101GR.prj'
project.write_text('KEY iCDBDir ".\\database"\nKEY PCBDesignPath "PCB/IP101GR.pcb"\n')
(work/'PCB/IP101GR.pcb').write_text('KEY ProjectFile "../IP101GR.prj"\n')
(work/'PCB/pcb.prj').write_text('KEY CentralLibrary "old.lmc"\n')
monkeypatch.setattr(entry, 'assert_native_idle', lambda: None)
request = VerifyRequest(library, 'IP101GR', tmp_path/'evidence', maintenance=True)
yield request, project, address
import cbb_refresh_verify.library_lock as locks
key = locks.LibraryLock(library).key
with locks._guard:
owner = locks._owners.pop(key, None)
if owner: owner['handle'].Close()
def test_explicit_maintenance_enters_official_repair_once_without_lostsession_fabrication(case, monkeypatch):
from cbb_refresh_verify import verify_runner as runner, native_repair
from test_native_repair import complete_native_success
request, project, address = case
calls = []
def repair(target, root, **kwargs):
calls.append('repair')
assert address.read_bytes() == b'old server address - preserved'
assert kwargs['maintenance_context']['addresses'][str(address.resolve())]['sha256']
# Native boundary fake simulates official removal of its address.
native_repair.backup_project(target, root/'complete-backup')
assert (root/'complete-backup/database/cdbsvr/sAddress.adr').read_bytes() == address.read_bytes()
address.unlink()
return complete_native_success(target)
monkeypatch.setattr(native_repair, 'run_native_repair', repair)
monkeypatch.setattr(native_repair, 'repair_release_state', lambda *a:
{'safe_to_continue': True, 'native_exited': True, 'addresses': []})
def verify(req, **kwargs):
calls.append('verify')
assert not req.maintenance and not req.auto_repair
assert req.lmc_file == request.lmc_file and req.block_name == request.block_name
return runner.VerifyResult('PASS', library_flag='GREEN')
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
result = runner.run_verify(request)
assert calls == ['repair', 'verify'] and result.status == 'PASS'
assert result.recovery_attempts[0]['validation_passed'] is True
record = json.loads(result.evidence_path.read_text(encoding='utf-8'))
assert record['operation'] == 'explicit_project_maintenance'
assert 'session' not in record['maintenance_context']
def test_ordinary_verify_still_blocks_existing_address_without_repair(case, monkeypatch):
from cbb_refresh_verify import verify_runner as runner, native_repair
request, _, address = case
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **k: pytest.fail('ordinary verify must not repair'))
result = runner.run_verify(replace(request, maintenance=False))
assert result.status == 'BLOCKED' and not result.safe_to_continue
assert address.read_bytes() == b'old server address - preserved'
@pytest.mark.parametrize('obstacle', ['active_owner', 'exclusive', 'shared_address', 'ambiguous', 'address_mutation'])
def test_maintenance_guard_blocks_before_native(case, monkeypatch, obstacle):
from cbb_refresh_verify import maintenance_entry as entry, native_repair, verify_runner as runner
import win32file, win32con
request, project, address = case
handle = None
if obstacle == 'active_owner':
monkeypatch.setattr(entry, 'assert_native_idle', lambda: (_ for _ in ()).throw(ValueError('native owner')))
if obstacle == 'exclusive':
handle = win32file.CreateFile(str(project.parent/'database/icdb.dat'), win32con.GENERIC_READ,
0, None, win32con.OPEN_EXISTING, 0, None)
if obstacle == 'shared_address':
shared = request.lmc_file.parent/'SymbolLibs/__ReusableBlocksSymb/cdbsvr/sAddress.adr'
shared.parent.mkdir(parents=True); shared.write_bytes(b'shared owner')
if obstacle == 'ambiguous': project.write_text(project.read_text() + 'KEY iCDBDir "other"\n')
if obstacle == 'address_mutation':
original = entry.address_snapshot
def mutate(paths):
result = original(paths)
address.write_bytes(b'changed after snapshot')
return result
monkeypatch.setattr(entry, 'address_snapshot', mutate)
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **k: pytest.fail('guard bypass'))
try:
result = runner.run_verify(request)
assert result.status == 'BLOCKED' and not result.safe_to_continue
finally:
if handle: handle.Close()
@pytest.mark.parametrize('change', ['dead', 'same_process', 'live_foreign', 'malformed', 'foreign_library', 'guard_failure'])
def test_takeover_preserves_old_checkpoint_until_every_guard_passes(case, monkeypatch, change):
from cbb_refresh_verify import library_lock as locks, maintenance_entry as entry
request, _, address = case
library = request.lmc_file
with locks.LibraryLock(library, safe_to_release=lambda: False): pass
marker = locks.blocker_path(library)
record = json.loads(marker.read_text(encoding='utf-8'))
if change != 'same_process':
with locks._guard: locks._owners.pop(locks.LibraryLock(library).key)['handle'].Close()
record['pid'] = 789123
if change == 'foreign_library': record['library'] = str(library.parent.parent/'foreign/mentor.lmc')
marker.write_text('broken json' if change == 'malformed' else json.dumps(record), encoding='utf-8')
old = marker.read_bytes()
monkeypatch.setattr(locks, '_supervisor_alive', lambda pid: change == 'live_foreign')
if change == 'guard_failure':
monkeypatch.setattr(entry, 'assert_native_idle', lambda: (_ for _ in ()).throw(ValueError('guard failed')))
archive = request.evidence_dir/'takeover'
guard = lambda: entry.maintenance_target_guard(request)
if change in ('dead', 'same_process'):
lease = locks.LibraryLock.for_maintenance(library, archive, guard, safe_to_release=lambda: True)
with lease:
assert (archive/'previous-checkpoint.json').read_bytes() == old
assert address.exists()
import win32file, win32con
with pytest.raises(Exception):
win32file.CreateFile(str(lease.path), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, 0, None)
assert lease.path.exists() and not marker.exists()
else:
with pytest.raises((ValueError, OSError)):
with locks.LibraryLock.for_maintenance(library, archive, guard): pass
assert marker.read_bytes() == old
@pytest.mark.parametrize('status', ['MISSING_HEALTHY_BACKUP', 'RESTORED_REVIEW_REQUIRED', 'DATABASE_BUSY', 'TIMEOUT_UNRELEASED'])
def test_nonrepair_outcomes_never_verify_or_count_success(case, monkeypatch, status):
from cbb_refresh_verify import native_repair, verify_runner as runner
request, _, _ = case
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **k: {
'status': status, 'release': {'safe_to_continue': False}, 'detail': 'native result'})
monkeypatch.setattr(native_repair, 'repair_release_state', lambda *a: {'safe_to_continue': False})
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: pytest.fail('unsafe or nonrepair outcome reopened'))
result = runner.run_verify(request)
assert result.status != 'PASS' and not result.safe_to_continue
assert result.recovery_attempts[0]['status'] == status
def test_native_success_cannot_bypass_remaining_address(case, monkeypatch):
from cbb_refresh_verify import native_repair, verify_runner as runner
from test_native_repair import complete_native_success
request, _, _ = case
monkeypatch.setattr(native_repair, 'run_native_repair', lambda target, *a, **k: complete_native_success(target))
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: pytest.fail('retained address reopened'))
# Native release queries remain mocked, actual address/exclusive checks stay real.
monkeypatch.setattr('cbb_refresh_verify.mentor_adapter.pcb_processes', lambda: [])
monkeypatch.setattr('cbb_refresh_verify.mentor_adapter._process_details', lambda name: [])
result = runner.run_verify(request)
assert result.status != 'PASS' and not result.safe_to_continue
@pytest.mark.parametrize('output', ['', 'Checking if project is in use.',
"Project is not in use. Full iCDB Project Backup's functionality is available.",
"Project is not in use. Full iCDB Project Backup's functionality is available.\nProject is in use."])
def test_explicit_worker_requires_positive_native_idle_before_repair(tmp_path, monkeypatch, output):
import win32con
from test_native_repair import repair_worker_fixture
import cbb_refresh_verify.maintenance_entry as entry
from cbb_refresh_verify.native_repair import RepairTarget
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'active')
values = json.loads(job.read_text())
values['maintenance_context'] = {'library': str(tmp_path/'lib.lmc'), 'block': 'CBB1'}
job.write_text(json.dumps(values))
@contextmanager
def guard(*args):
yield {'target': RepairTarget(Path(values['project']), Path(values['database']))}
monkeypatch.setattr(entry, 'maintenance_target_guard', guard)
monkeypatch.setattr(ui, '_native_output', lambda windows: output)
ui.repair_worker_main(job)
expected = output == "Project is not in use. Full iCDB Project Backup's functionality is available."
assert any(message == win32con.WM_COMMAND for _, message in actions) is expected
def test_worker_rechecks_address_after_complete_backup_before_native_launch(tmp_path, monkeypatch):
from test_native_repair import repair_worker_fixture
import cbb_refresh_verify.maintenance_entry as entry
from cbb_refresh_verify.native_repair import RepairTarget
ui, root, job, _ = repair_worker_fixture(tmp_path, monkeypatch, 'active')
values = json.loads(job.read_text()); values['maintenance_context'] = {'library': str(tmp_path/'lib.lmc'), 'block': 'CBB1'}
job.write_text(json.dumps(values))
calls = []
@contextmanager
def guard(*args):
calls.append('guard')
if len(calls) == 2: raise ValueError('address changed during complete backup')
yield {'target': RepairTarget(Path(values['project']), Path(values['database']))}
monkeypatch.setattr(entry, 'maintenance_target_guard', guard)
monkeypatch.setattr(ui.subprocess, 'Popen', lambda *a, **k: pytest.fail('mutation must stop native launch'))
ui.repair_worker_main(job)
assert calls == ['guard', 'guard']
assert 'address changed' in json.loads((root/'repair-result.json').read_text())['detail']
def test_guard_failure_keeps_takeover_checkpoint_byte_exact_when_address_changes(case, monkeypatch):
from cbb_refresh_verify import library_lock as locks, maintenance_entry as entry
request, _, address = case
with locks.LibraryLock(request.lmc_file, safe_to_release=lambda: False): pass
marker = locks.blocker_path(request.lmc_file); old = marker.read_bytes()
snapshot = entry.address_snapshot
def mutate(paths):
result = snapshot(paths); address.write_bytes(b'changed'); return result
monkeypatch.setattr(entry, 'address_snapshot', mutate)
with pytest.raises(ValueError):
with locks.LibraryLock.for_maintenance(request.lmc_file, request.evidence_dir/'takeover',
lambda: entry.maintenance_target_guard(request)): pass
assert marker.read_bytes() == old
def test_independent_cbb_address_does_not_select_or_block_current_project(case):
from cbb_refresh_verify.maintenance_entry import maintenance_target_guard
request, project, address = case
other = request.lmc_file.parent/'ReusableBlocksLP/1GPHY_8212/Work/database/cdbsvr/sAddress.adr'
other.parent.mkdir(parents=True); other.write_bytes(b'independent CBB original address')
with maintenance_target_guard(request) as checked:
assert checked['target'].project == project
assert set(checked['context']['addresses']) == {str(address.resolve())}
assert other.read_bytes() == b'independent CBB original address'
assert other.read_bytes() == b'independent CBB original address'