140 lines
7.9 KiB
Python
140 lines
7.9 KiB
Python
"""Run the real management engine with only the native/export boundaries faked."""
|
|
from dataclasses import replace
|
|
import json
|
|
from pathlib import Path
|
|
import shutil
|
|
|
|
import pytest
|
|
|
|
|
|
@pytest.fixture
|
|
def transaction(tmp_path, monkeypatch):
|
|
from test_management import project
|
|
import cbb_refresh_verify.native_management as native
|
|
import cbb_refresh_verify.native_engineering_identity as identity
|
|
import cbb_refresh_verify.backup_recovery as recovery
|
|
from cbb_refresh_verify.management import ManagementRequest, engineering_identity, _write_json
|
|
from cbb_refresh_verify.management_transaction import validate_transaction
|
|
root = tmp_path/'probe'
|
|
library = root/'native-add/fixture/mentor_lib.lmc'
|
|
library.parent.mkdir(parents=True); library.write_bytes(b'fixture library')
|
|
(root/'probe-owner.json').write_text(json.dumps({'library': str(library), 'token': 'owned'}), encoding='utf-8')
|
|
source = project(tmp_path/'source')
|
|
for path in (source, source.parent/'PCB/pcb.prj'):
|
|
with path.open('a') as stream: stream.write(f'KEY CentralLibrary "{library}"\n')
|
|
state = {'entries': [], 'calls': [], 'corrupt': False, 'fail_add': False}
|
|
monkeypatch.setattr(native.NativeManagementAdapter, '_binary_capability', lambda _: '')
|
|
monkeypatch.setattr(identity, 'check_exporters', lambda _: None)
|
|
monkeypatch.setattr(recovery, '_idle_check', lambda *_: None)
|
|
def capture(source, evidence, *, expected_library, **kwargs):
|
|
evidence = Path(evidence); evidence.mkdir(parents=True, exist_ok=False)
|
|
value = identity.asset_identity(source, expected_library)
|
|
value.update(ascii_sha256='logical', csv={'work/identity': 'tables'}, edif_sha256='geometry')
|
|
_write_json(evidence/'identity.json', {'identity': value, 'safe_to_continue': True})
|
|
return identity.IdentityOutcome(value, True, 'file-only export proof', evidence)
|
|
monkeypatch.setattr(identity, 'capture_identity', capture)
|
|
def worker(adapter, job, evidence):
|
|
evidence = Path(evidence); evidence.mkdir(parents=True, exist_ok=False)
|
|
state['calls'].append(job['operation'])
|
|
if job['operation'] == 'catalog':
|
|
return {'success': True, 'safe_to_continue': True, 'library': str(library), 'flow': 1,
|
|
'entries': list(state['entries'])}
|
|
if job['operation'] == 'add':
|
|
if state.get('tamper') == 'nonce': job['transaction_nonce'] = 'foreign'
|
|
if state.get('tamper') == 'supervisor': job['supervisor_pid'] = -1
|
|
if state.get('tamper') == 'backup':
|
|
(evidence.parent/'library-before'/library.name).write_bytes(b'corrupted backup')
|
|
if state.get('tamper') == 'source':
|
|
(Path(job['source']).parent/'database/icdb.dat').write_bytes(b'changed staged input')
|
|
validate_transaction(job, evidence.parent)
|
|
if state['fail_add']: return {'success': False, 'safe_to_continue': True, 'detail': 'native failure'}
|
|
staged = Path(job['source'])
|
|
(staged.parent/'database/icdb.dat').write_bytes(b'native database normalization')
|
|
work = library.parent/'ReusableBlocksLP'/job['name']/'Work'
|
|
shutil.copytree(staged.parent, work)
|
|
pcb_project = work/'PCB/pcb.prj'
|
|
text = pcb_project.read_text()
|
|
import re
|
|
pcb_project.write_text(re.sub(r'KEY CentralLibrary "[^"]*"', 'KEY CentralLibrary "wrong-relative.lmc"', text))
|
|
if state['corrupt'] == 'unknown_cdbsvr':
|
|
unknown = work/'database/cdbsvr/persistent.dat'; unknown.parent.mkdir(parents=True, exist_ok=True)
|
|
unknown.write_bytes(b'unexpected engineering content')
|
|
elif state['corrupt']: (work/'PCB/Layout/LayoutDB.lyt').write_bytes(b'wrong physical design')
|
|
state['entries'] = [{'name': job['name'], 'partition': job['partition'],
|
|
'engineering_identity': engineering_identity(work/staged.name)}]
|
|
return {'success': True, 'safe_to_continue': True, 'identity_matches': False}
|
|
if job['operation'] == 'remove':
|
|
state['entries'] = []
|
|
shutil.rmtree(library.parent/'ReusableBlocksLP'/job['name'])
|
|
return {'success': True, 'safe_to_continue': True}
|
|
pytest.fail('unexpected native operation')
|
|
monkeypatch.setattr(native.NativeManagementAdapter, '_worker', worker)
|
|
request = ManagementRequest('add', library, 'Block', source=source, auto_verify=False,
|
|
evidence_dir=tmp_path/'evidence')
|
|
yield root, request, state
|
|
from cbb_refresh_verify.library_lock import LibraryLock, _owners, _guard, blocker_path
|
|
with _guard:
|
|
owner = _owners.pop(LibraryLock(library).key, None)
|
|
if owner: owner['handle'].Close()
|
|
blocker_path(library).unlink(missing_ok=True)
|
|
|
|
|
|
def execute(root, request):
|
|
from cbb_refresh_verify.native_management import run_owned_fixture_management
|
|
return run_owned_fixture_management(request, root, probe_token='owned', idle_check=lambda *_: None)
|
|
|
|
|
|
def test_owned_fixture_engine_add_conflict_update_remove_and_identity(transaction):
|
|
from cbb_refresh_verify.native_engineering_identity import project_library
|
|
root, request, state = transaction
|
|
original = request.source.read_bytes()
|
|
assert execute(root, request).status == 'UPLOADED'
|
|
registered = request.library.parent/'ReusableBlocksLP/Block/Work/Source.prj'
|
|
assert project_library(registered) == request.library.resolve()
|
|
calls = len(state['calls'])
|
|
assert execute(root, request).status == 'UPLOAD_FAILED'
|
|
assert state['calls'][calls:] == ['catalog']
|
|
(request.source.parent/'PCB/Layout/LayoutDB.lyt').write_bytes(b'replacement physical design')
|
|
assert execute(root, replace(request, operation='update')).status == 'UPLOADED'
|
|
assert (registered.parent/'PCB/Layout/LayoutDB.lyt').read_bytes() == b'replacement physical design'
|
|
assert execute(root, replace(request, operation='remove', source=None)).status == 'REMOVED'
|
|
assert execute(root, request).status == 'UPLOADED'
|
|
assert request.source.read_bytes() == original
|
|
|
|
|
|
@pytest.mark.parametrize('corrupt', [True, 'unknown_cdbsvr'])
|
|
def test_native_registered_but_asset_mismatch_retains_recovery(transaction, corrupt):
|
|
root, request, state = transaction
|
|
state['corrupt'] = corrupt
|
|
result = execute(root, request)
|
|
assert result.status == 'RECOVERY_REQUIRED' and not result.safe_to_continue
|
|
|
|
|
|
def test_update_readd_failure_preserves_snapshot_and_removed_checkpoint(transaction):
|
|
root, request, state = transaction
|
|
assert execute(root, request).status == 'UPLOADED'
|
|
state['fail_add'] = True
|
|
result = execute(root, replace(request, operation='update'))
|
|
assert result.status == 'RECOVERY_REQUIRED' and not result.safe_to_continue
|
|
assert (result.evidence_path.parent/'library-before/ReusableBlocksLP/Block/Work/Source.prj').exists()
|
|
assert 'removed' in [entry['stage'] for entry in json.loads(result.evidence_path.read_text())['history']]
|
|
|
|
|
|
def test_fixture_grant_cannot_authorize_arbitrary_library(transaction, tmp_path):
|
|
from cbb_refresh_verify.native_management import run_owned_fixture_management
|
|
root, request, state = transaction
|
|
other = tmp_path/'production.lmc'; other.write_bytes(b'unchanged')
|
|
with pytest.raises(ValueError):
|
|
run_owned_fixture_management(replace(request, library=other), root, probe_token='owned')
|
|
assert other.read_bytes() == b'unchanged' and not state['calls']
|
|
|
|
|
|
@pytest.mark.parametrize('tamper', ['nonce', 'supervisor', 'backup', 'source'])
|
|
def test_worker_rejects_modified_management_authority_before_add(transaction, tamper):
|
|
root, request, state = transaction
|
|
state['tamper'] = tamper
|
|
original = request.source.read_bytes()
|
|
result = execute(root, request)
|
|
assert result.status == 'RECOVERY_REQUIRED' and not result.safe_to_continue
|
|
assert state['entries'] == [] and request.source.read_bytes() == original
|