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

363 lines
17 KiB
Python

"""Operation safety tests use a file-only native boundary; never launch Mentor."""
from dataclasses import replace
import json
from pathlib import Path
from threading import Event
import pytest
def project(root, name='Source', marker=b'original'):
root.mkdir(parents=True)
(root/'database').mkdir()
(root/'database/icdb.dat').write_bytes(marker)
(root/'PCB/Layout').mkdir(parents=True)
(root/'PCB/Layout/LayoutDB.lyt').write_bytes(marker)
(root/'PCB/pcb.prj').write_text('KEY iCDBDir "../database"\n', encoding='utf-8')
(root/'PCB/main.pcb').write_text(f'KEY ProjectFile "../{name}.prj"\n', encoding='utf-8')
path = root/f'{name}.prj'
path.write_text('KEY RootBlock "Top"\nKEY PCBDesignPath "PCB/main.pcb"\n'
'KEY iCDBDir "database"\n', encoding='utf-8')
return path
class FileAdapter:
def __init__(self):
self.records = []
self.calls = []
self.fail_add = False
self.lie = False
self.released = True
def capabilities(self):
from cbb_refresh_verify.management import Capability
return {op: Capability(True, 'test boundary') for op in ('add', 'update', 'remove')}
def catalog(self, library, evidence):
from cbb_refresh_verify.management import Catalog
return Catalog(library, 1, tuple(self.records), safe_to_continue=self.released)
def remove(self, request, evidence):
from cbb_refresh_verify.management import NativeOutcome
self.calls.append('remove')
if not self.lie:
self.records = [r for r in self.records if r.name != request.name]
return NativeOutcome(True, self.released, 'native removal accepted')
def add(self, request, evidence):
from cbb_refresh_verify.management import NativeOutcome, CatalogEntry, engineering_identity
self.calls.append(('add', request.source))
if self.fail_add:
return NativeOutcome(False, self.released, 'native add failed')
if not self.lie:
self.records.append(CatalogEntry(request.name, request.partition,
engineering_identity(request.source)))
return NativeOutcome(True, self.released, 'native add accepted')
@pytest.fixture
def setup(tmp_path):
from cbb_refresh_verify.management import ManagementRequest, CatalogEntry
library = tmp_path/'library/mentor.lmc'
library.parent.mkdir()
library.write_bytes(b'library')
old = project(library.parent/'ReusableBlocksLP/Block/Work', 'Block')
source = project(tmp_path/'source')
adapter = FileAdapter()
adapter.records = [CatalogEntry('Block', 'Logical-Physical')]
request = ManagementRequest('remove', library, 'Block', evidence_dir=tmp_path/'evidence')
yield request, adapter, source
# FileAdapter never launches native owners. Release only this test's
# intentionally retained lease so pytest can remove its temporary tree.
from cbb_refresh_verify.library_lock import _guard, _owners
key = str(library.with_name('.mentor.cbb-upload.lock').resolve()).casefold()
with _guard:
owner = _owners.pop(key, None)
if owner:
owner['handle'].Close()
def execute(request, adapter, **kwargs):
from cbb_refresh_verify.management import run_management
return run_management(request, adapter=adapter, idle_check=lambda *_: None, **kwargs)
def test_remove_uses_baseline_without_automatic_library_backup(setup):
request, adapter, _ = setup
result = execute(request, adapter)
assert result.status == 'REMOVED' and result.safe_to_continue
assert not (result.evidence_path.parent/'library-before').exists()
assert (result.evidence_path.parent/'library-baseline-manifest.json').is_file()
assert '已备份' not in result.detail
record = json.loads(result.evidence_path.read_text(encoding='utf-8'))
assert record['operation'] == 'remove' and record['partition'] == 'Logical-Physical'
assert record['stage'] == 'complete'
@pytest.mark.parametrize('operation', ['add', 'update', 'remove'])
def test_management_never_copies_target_library(setup, monkeypatch, operation):
import cbb_refresh_verify.management as management
request, adapter, source = setup
real_copy = management.copy_verified
def copy(source_path, destination, **kwargs):
assert Path(source_path).resolve() != request.library.parent.resolve(), 'automatic whole-library backup'
return real_copy(source_path, destination, **kwargs)
monkeypatch.setattr(management, 'copy_verified', copy)
result = execute(replace(request, operation=operation, source=source if operation != 'remove' else None,
name='New' if operation == 'add' else 'Block', auto_verify=False), adapter)
assert result.status == ('REMOVED' if operation == 'remove' else 'UPLOADED')
@pytest.mark.parametrize('relative', ['mentor.lmc', 'SymbolLibs/shared/icdb.dat',
'ReusableBlocksLP/Other/Work/database/icdb.dat'])
def test_manual_backup_policy_still_rejects_external_shared_read_owner(setup, relative):
import win32con, win32file
request, adapter, _ = setup
path = request.library.parent/relative
path.parent.mkdir(parents=True, exist_ok=True)
if not path.exists():
path.write_bytes(b'owned database')
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, win32con.FILE_SHARE_READ, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
try:
result = execute(request, adapter)
assert result.status == 'BLOCKED'
assert not adapter.calls, 'An existing reader must block native writes even without address/process evidence'
assert not list(request.evidence_dir.rglob('library-before'))
finally:
handle.Close()
def test_add_conflict_cannot_overwrite(setup):
request, adapter, source = setup
result = execute(replace(request, operation='add', source=source), adapter)
assert result.status == 'UPLOAD_FAILED' and adapter.calls == []
@pytest.mark.parametrize('verify_status,flag,expected', [('PASS', 'GREEN', 'UPLOADED_VERIFIED'),
('FAIL', 'RED', 'UPLOADED_VERIFY_FAILED'), ('PASS', 'UNKNOWN', 'UPLOADED_VERIFY_FAILED')])
def test_add_stages_source_and_requires_authoritative_verify(setup, verify_status, flag, expected):
from cbb_refresh_verify.verify_runner import VerifyResult
request, adapter, source = setup
original = source.read_bytes()
def verifier(req, **_):
assert adapter.released
return VerifyResult(verify_status, library_flag=flag)
result = execute(replace(request, operation='add', name='New', source=source), adapter,
verifier=verifier)
assert result.status == expected and source.read_bytes() == original
assert adapter.calls[0][1] != source
assert adapter.calls[0][1].is_relative_to(result.evidence_path.parent)
def test_add_no_auto_verify_and_reimport_after_remove(setup):
request, adapter, source = setup
assert execute(request, adapter).status == 'REMOVED'
result = execute(replace(request, operation='add', source=source, auto_verify=False), adapter,
verifier=lambda *_: pytest.fail('auto verify disabled'))
assert result.status == 'UPLOADED'
def test_update_failed_readd_keeps_removed_checkpoint_and_baseline(setup):
request, adapter, source = setup
adapter.fail_add = True
result = execute(replace(request, operation='update', source=source), adapter)
assert result.status == 'RECOVERY_REQUIRED' and result.safe_to_continue
assert adapter.records == []
history = json.loads(result.evidence_path.read_text(encoding='utf-8'))['history']
assert 'removed' in [x['stage'] for x in history]
assert (result.evidence_path.parent/'library-baseline-manifest.json').is_file()
assert not (result.evidence_path.parent/'library-before').exists()
@pytest.mark.parametrize('operation', ['remove', 'add'])
def test_lying_native_output_does_not_report_success(setup, operation):
request, adapter, source = setup
adapter.lie = True
request = replace(request, operation=operation, source=source,
name='New' if operation == 'add' else 'Block')
result = execute(request, adapter)
assert result.status == 'RECOVERY_REQUIRED' and result.safe_to_continue
def test_unreleased_native_owner_prevents_postread_and_verification(setup):
request, adapter, _ = setup
original = adapter.remove
def unreleased(*args):
adapter.released = False
return original(*args)
adapter.remove = unreleased
reads = []
catalog = adapter.catalog
adapter.catalog = lambda *a: (reads.append(1) or catalog(*a))
result = execute(request, adapter, verifier=lambda *_: pytest.fail('unsafe verify'))
assert not result.safe_to_continue and len(reads) == 1
from cbb_refresh_verify.library_lock import LibraryLock, LibraryBusy
with pytest.raises(LibraryBusy):
with LibraryLock(request.library):
pass
@pytest.mark.parametrize('name', ['../escape', 'A\tB', 'A\nB', 'A/B', 'NUL', 'a.', ''])
def test_invalid_native_identity_rejected_before_writes(setup, name):
request, adapter, _ = setup
result = execute(replace(request, name=name), adapter)
assert result.status == 'BLOCKED' and adapter.calls == []
def test_evidence_inside_target_rejected(setup):
request, adapter, _ = setup
result = execute(replace(request, evidence_dir=request.library.parent/'evidence'), adapter)
assert result.status == 'BLOCKED' and not (request.library.parent/'evidence').exists()
def test_cancel_and_restart_never_replay(setup):
from cbb_refresh_verify.management import run_management_batch, unfinished_operations
request, adapter, _ = setup
stop = Event(); stop.set()
assert run_management_batch([request], stop=stop, adapter=adapter) == []
checkpoint = request.evidence_dir/'interrupted/checkpoint.json'
checkpoint.parent.mkdir(parents=True)
checkpoint.write_text('{"stage":"native_remove", "status":"RUNNING"}', encoding='utf-8')
found = unfinished_operations(request.evidence_dir)
assert len(found) == 1 and found[0]['evidence_path'] == str(checkpoint)
assert adapter.calls == []
def test_capability_gate_enforced_below_ui(setup):
from cbb_refresh_verify.management import Capability
request, adapter, source = setup
adapter.capabilities = lambda: {'add': Capability(False, 'isolated add not validated')}
result = execute(replace(request, operation='add', name='New', source=source), adapter)
assert result.status == 'UNSUPPORTED' and 'isolated' in result.detail
assert adapter.calls == []
def test_timeout_stops_batch_and_persists_ambiguous_native_stage(setup):
from cbb_refresh_verify.management import run_management_batch
request, adapter, _ = setup
def timeout(*_):
raise TimeoutError('network timeout')
adapter.remove = timeout
results = run_management_batch([request, replace(request, name='Other')], adapter=adapter,
idle_check=lambda *_: None)
assert len(results) == 1 and not results[0].safe_to_continue
assert results[0].status == 'RECOVERY_REQUIRED'
def test_catalog_timeout_is_not_safe_to_continue(setup):
request, adapter, _ = setup
def timeout(*_):
raise TimeoutError('catalog owner still running')
adapter.catalog = timeout
result = execute(request, adapter)
assert not result.safe_to_continue and adapter.calls == []
def test_replaced_source_bytes_fail_identity_even_with_same_name(setup):
request, adapter, source = setup
real_add = adapter.add
def wrong_source(*args):
from cbb_refresh_verify.management import CatalogEntry
result = real_add(*args)
entry = adapter.records[-1]
adapter.records[-1] = CatalogEntry(entry.name, entry.partition, {'wrong': 'project'})
return result
adapter.add = wrong_source
result = execute(replace(request, operation='add', name='New', source=source), adapter)
assert result.status == 'RECOVERY_REQUIRED' and result.safe_to_continue
def test_update_success_requires_same_identity_and_no_implicit_partition_move(setup):
request, adapter, source = setup
result = execute(replace(request, operation='update', source=source, partition='Other'), adapter)
assert result.status == 'BLOCKED' and not adapter.calls
result = execute(replace(request, operation='update', source=source, auto_verify=False), adapter)
assert result.status == 'UPLOADED'
assert adapter.calls[0] == 'remove' and adapter.calls[1][0] == 'add'
def test_verify_exception_after_upload_retains_coordination_lock(setup):
from cbb_refresh_verify.library_lock import LibraryLock, LibraryBusy
request, adapter, source = setup
def broken_verifier(*a, **k):
raise OSError('verification worker disconnected')
result = execute(replace(request, operation='add', name='New', source=source), adapter,
verifier=broken_verifier)
assert result.status == 'UPLOADED_VERIFY_FAILED' and not result.safe_to_continue
with pytest.raises(LibraryBusy):
with LibraryLock(request.library):
pass
@pytest.mark.parametrize('nested', [True, False])
def test_library_inside_source_tree_rejected_before_catalog_or_guard(setup, nested):
request, adapter, source = setup
library = source.parent/('nested/lib.lmc' if nested else 'lib.lmc')
library.parent.mkdir(exist_ok=True)
library.write_bytes(b'library')
adapter.catalog = lambda *a: pytest.fail('overlapping library reached native catalog')
result = execute(replace(request, operation='add', name='New', source=source, library=library), adapter)
assert result.status == 'BLOCKED' and not adapter.calls
assert not library.with_name('.lib.cbb-upload.lock').exists()
assert not request.evidence_dir.exists()
def test_mapped_library_spelling_and_context_survive_engine_verify_boundary(setup, monkeypatch):
import shutil
from cbb_refresh_verify.verify_runner import VerifyResult
request, adapter, source = setup
alias_root = request.library.parent
canonical_root = alias_root.with_name('canonical-library')
shutil.copytree(alias_root, canonical_root)
original_resolve = Path.resolve
def resolve(path, *a, **k):
if path.is_relative_to(alias_root):
return original_resolve(canonical_root/path.relative_to(alias_root), *a, **k)
return original_resolve(path, *a, **k)
monkeypatch.setattr(Path, 'resolve', resolve)
catalogs, verified = [], []
catalog = adapter.catalog
adapter.catalog = lambda library, evidence: (catalogs.append(library) or catalog(library, evidence))
def verifier(req, **k):
verified.append(req)
return VerifyResult('PASS', library_flag='GREEN')
request = replace(request, operation='add', name='New', source=source,
mapped_drive='S:', mapped_remote_root=r'\\server\share')
result = execute(request, adapter, verifier=verifier)
assert result.status == 'UPLOADED_VERIFIED'
assert catalogs == [request.library, request.library]
assert verified[0].lmc_file == request.library
assert verified[0].mapped_drive == 'S:' and verified[0].mapped_remote_root == r'\\server\share'
def test_source_inside_target_library_rejected_before_catalog(setup):
request, adapter, _ = setup
source = request.library.parent/'ReusableBlocksLP/Block/Work/Block.prj'
adapter.catalog = lambda *a: pytest.fail('overlapping source reached native catalog')
result = execute(replace(request, operation='add', name='New', source=source), adapter)
assert result.status == 'BLOCKED' and not request.evidence_dir.exists()
@pytest.mark.parametrize('matched', [True, False])
def test_prepared_native_identity_is_required_after_exact_catalog(setup, matched):
from cbb_refresh_verify.native_engineering_identity import IdentityOutcome
from cbb_refresh_verify.management import NativeOutcome
request, adapter, source = setup
expected = {'policy': 'native-test', 'logical': 'same', 'physical': 'same'}
def prepare(staged, root, *, original_source):
assert original_source == source and staged.source != source
assert (root/'library-baseline-manifest.json').exists()
adapter.calls.append('prepare_identity')
return staged, IdentityOutcome(expected, True, 'baseline captured', root)
adapter.prepare_add_transaction = prepare
original_add = adapter.add
def add(staged, evidence):
original_add(staged, evidence)
return NativeOutcome(True, True, 'native registered', identity_matches=matched,
identity_proof=expected if matched else {'different': True})
adapter.add = add
result = execute(replace(request, operation='update', source=source, auto_verify=False), adapter)
assert adapter.calls[0:2] == ['prepare_identity', 'remove']
assert result.status == ('UPLOADED' if matched else 'RECOVERY_REQUIRED')