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

190 lines
9.9 KiB
Python

"""Exercise actual guards/snapshots; only the native worker transport is fake."""
from dataclasses import asdict
import json
from pathlib import Path
import pytest
@pytest.fixture(autouse=True)
def prohibit_native_launch(monkeypatch):
"""Backstop independent of the boundary under development: no live apps."""
import subprocess, win32process, win32com.client
import cbb_refresh_verify.desktop_worker as desktop
def forbidden(*a, **k):
raise AssertionError('Native/process launch is forbidden in probe-guard tests')
monkeypatch.setattr(desktop, 'DesktopWorker', forbidden)
monkeypatch.setattr(win32process, 'CreateProcess', forbidden)
monkeypatch.setattr(subprocess, 'Popen', forbidden)
monkeypatch.setattr(win32com.client, 'Dispatch', forbidden)
monkeypatch.setattr(win32com.client, 'DispatchEx', forbidden)
@pytest.fixture
def probe_files(tmp_path):
def source(root, data):
(root/'database').mkdir(parents=True)
(root/'database/icdb.dat').write_bytes(data)
(root/'PCB/Layout').mkdir(parents=True)
(root/'PCB/Layout/LayoutDB.lyt').write_bytes(data)
(root/'PCB/pcb.prj').write_text('KEY CentralLibrary "old.lmc"\n')
(root/'PCB/Block.pcb').write_text('KEY ProjectFile "../Block.prj"\n')
project = root/'Block.prj'
project.write_text('KEY RootBlock "Block"\nKEY iCDBDir "database"\nKEY PCBDesignPath "PCB/Block.pcb"\n')
return project
original = source(tmp_path/'original', b'original')
replacement = source(tmp_path/'replacement', b'replacement')
root = tmp_path/'probe'
yield original, replacement, root
# Only file fakes ran; close this test's deliberately retained OS handle.
import cbb_refresh_verify.library_lock as locks
library = root/'native-add/fixture/mentor_lib.lmc'
with locks._guard:
owner = locks._owners.pop(locks._key(library.with_name('.mentor_lib.cbb-upload.lock')), None)
if owner:
owner['handle'].Close()
@pytest.mark.parametrize('fault', ['create_unsafe', 'first_catalog_exception', 'remove_unsafe',
'remove_exception', 'after_remove_exception', 'readd_unsafe', 'readd_exception', 'final_catalog_exception'])
def test_isolated_probe_retains_guard_on_uncertain_native_lifecycle(probe_files, monkeypatch, fault):
import cbb_refresh_verify.native_management as native
import cbb_refresh_verify.library_lock as locks
from cbb_refresh_verify.management import Capability, CatalogEntry, engineering_identity
original, replacement, root = probe_files
records = []
monkeypatch.setattr(native.NativeManagementAdapter, 'capabilities', lambda self:
{'remove': Capability(True, 'file transport fixture')})
def launch(self, job, evidence):
nonlocal records
evidence = Path(evidence)
operation = job['operation']
library = Path(job['library'])
if operation == 'probe_create_add':
# Directory creation belongs to the real supervising adapter.
assert native.prepare_probe_library(job, evidence) == library
library.write_bytes(b'native-created fixture')
(root/'probe-owner.json').write_text(json.dumps({'library': str(library), 'token': job['probe_token']}))
records = [CatalogEntry(job['name'], 'Logical-Physical', engineering_identity(job['source']))]
if fault == 'create_unsafe':
return {'success': False, 'safe_to_continue': False, 'detail': 'creation owner retained'}
elif operation == 'remove':
if fault == 'remove_exception':
raise TimeoutError('native removal transport disconnected')
if fault == 'remove_unsafe':
return {'success': False, 'safe_to_continue': False, 'detail': 'removal owner retained'}
records = []
elif operation == 'probe_readd':
if fault == 'readd_exception':
raise TimeoutError('native readd transport disconnected')
if fault == 'readd_unsafe':
return {'success': False, 'safe_to_continue': False, 'detail': 'readd owner retained'}
records = [CatalogEntry(job['name'], 'Logical-Physical', engineering_identity(job['source']))]
elif operation == 'catalog':
stage_fault = {'reopen': 'first_catalog_exception', 'after-remove': 'after_remove_exception',
'reopen-update': 'final_catalog_exception'}.get(evidence.name)
if stage_fault == fault:
raise TimeoutError('catalog owner release unknown')
return {'success': True, 'safe_to_continue': True, 'library': str(library), 'flow': 1,
'entries': [asdict(entry) for entry in records], 'detail': 'file fixture result'}
class Worker:
def __init__(self, command, desktop):
request = Path(command[-1])
job = json.loads(request.read_text(encoding='utf-8'))
result = launch(None, job, request.parent)
(request.parent/'result.json').write_text(json.dumps(result), encoding='utf-8')
def poll(self): return 0
def close(self): pass
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', Worker)
try:
native.run_isolated_probe(original, root, 'Block', replacement_source=replacement)
except TimeoutError:
pass
library = root/'native-add/fixture/mentor_lib.lmc'
assert locks.has_blocker(library)
with pytest.raises(locks.LibraryBusy):
with locks.LibraryLock(library): pass
assert (root/'probe-result.json').is_file()
from contextlib import contextmanager
@contextmanager
def denied(*a):
raise locks.LibraryBusy('fresh proof still sees a native owner')
yield
monkeypatch.setattr(locks, '_prove_library_released', denied)
with pytest.raises(locks.LibraryBusy):
locks.release_retained_library(library, root/'release-checks')
assert locks.has_blocker(library)
@contextmanager
def released(*a):
yield {'native_owners': [], 'addresses': [], 'exclusive_files': [str(library)]}
monkeypatch.setattr(locks, '_prove_library_released', released)
assert locks.release_retained_library(library, root/'release-checks')['status'] == 'RELEASE_CONFIRMED'
with locks.LibraryLock(library): pass
def test_mapping_context_is_serialized_and_restored_before_catalog(tmp_path, monkeypatch):
import cbb_refresh_verify.native_management as native
import cbb_refresh_verify.network_path as network
captured = []
class Worker:
def __init__(self, command, desktop):
request = Path(command[-1])
job = json.loads(request.read_text(encoding='utf-8'))
captured.append(job)
(request.parent/'result.json').write_text(json.dumps({'success': True, 'safe_to_continue': True,
'library': job['library'], 'flow': 1, 'entries': []}), encoding='utf-8')
def poll(self): return 0
def close(self): pass
adapter = native.NativeManagementAdapter(worker_factory=Worker)
adapter.bind_library_mapping('S:', r'\\server\share')
library = Path('S:/library/mentor.lmc')
adapter.catalog(library, tmp_path/'catalog')
assert captured[0]['library'] == str(library)
assert captured[0]['mapped_drive'] == 'S:'
order = []
monkeypatch.setattr(native, '_current_desktop', lambda: (None, captured[0]['desktop']))
monkeypatch.setattr(network, 'ensure_mapped_drive_visible', lambda drive, remote:
order.append(('mapping', drive, remote)))
monkeypatch.setattr(native, '_catalog_native', lambda job, root:
(order.append(('catalog', job['library'])) or {'success': True, 'safe_to_continue': True}))
assert native.management_worker_main(tmp_path/'catalog/request.json') == 0
assert order == [('mapping', 'S:', r'\\server\share'), ('catalog', str(library))]
def test_removal_cli_keeps_mapped_drive_spelling(tmp_path, monkeypatch):
import cbb_refresh_verify.native_management as native
from cbb_refresh_verify.management import Capability
job = {'operation': 'remove', 'library': 'S:\\library\\mentor.lmc', 'name': 'Block',
'partition': 'Logical-Physical', 'desktop': 'CbbManagement_fixture',
'mentor_home': str(tmp_path), 'timeout_seconds': 10}
request = tmp_path/'request.json'; request.write_text(json.dumps(job), encoding='utf-8')
monkeypatch.setattr(native, '_current_desktop', lambda: (None, job['desktop']))
monkeypatch.setattr(native.NativeManagementAdapter, 'capabilities', lambda self: {'remove': Capability(True, 'fake transport')})
commands = []
class Process:
pid = 1234
def __init__(self, command, *, stdout, **kwargs):
commands.append(command)
stdout.write(b"# Note: Removed REUSE_BLOCK 'Block' from partition 'Logical-Physical'.\n")
stdout.flush()
def wait(self, **kwargs): return 0
monkeypatch.setattr(native.subprocess, 'Popen', Process)
assert native.management_worker_main(request) == 0
assert commands[0][1] == job['library']
def test_staged_project_alignment_keeps_selected_mapped_drive(tmp_path, monkeypatch):
from cbb_refresh_verify.backup_recovery import _align_library
project = tmp_path/'Block.prj'
project.write_text('KEY CentralLibrary "old.lmc"\n', encoding='utf-8')
pcb = tmp_path/'PCB/Block.pcb'; pcb.parent.mkdir(); pcb.touch()
pcb_project = pcb.parent/'pcb.prj'
pcb_project.write_text('KEY CentralLibrary "old.lmc"\n', encoding='utf-8')
library = Path('S:/library/mentor.lmc')
original_resolve = Path.resolve
monkeypatch.setattr(Path, 'resolve', lambda path, *a, **k:
Path(r'\\server\share\library\mentor.lmc') if path == library else original_resolve(path, *a, **k))
_align_library(project, pcb, library)
for path in (project, pcb_project):
assert 'KEY CentralLibrary "S:\\library\\mentor.lmc"' in path.read_text(encoding='utf-8')