192 lines
10 KiB
Python
192 lines
10 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 captured[0]['worker_role'] == 'catalog_readonly'
|
|
assert native.catalog_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,
|
|
'supervisor_pid': __import__('os').getpid()}
|
|
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')
|