363 lines
17 KiB
Python
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 not 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 not 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 not 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')
|