"""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')