"""Resource release must not inherit another project's session or late evidence.""" from contextlib import contextmanager from concurrent.futures import ThreadPoolExecutor import json import subprocess import sys import threading import pytest import win32con import win32file from cbb_refresh_verify import library_lock as locks from cbb_refresh_verify import residual_sessions, session_record def library_file(tmp_path, name='A'): path = tmp_path/name/'lib.lmc' path.parent.mkdir() path.touch() return path def cleanup(lease): with locks._guard: owner = locks._owners.pop(lease.key, None) if owner: owner['handle'].Close() def test_residual_release_preserves_selected_scope_and_releases_parent_sidecar(tmp_path, monkeypatch): library = library_file(tmp_path) other = library.parent/'ReusableBlocksLP/B/Work/database/cdbsvr/sAddress.adr' other.parent.mkdir(parents=True) other.write_bytes(b'other native address') monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda *_: []) monkeypatch.setattr(residual_sessions, 'query_process_snapshot', lambda: []) monkeypatch.setattr(residual_sessions, '_process_windows', lambda _: {}) with locks.LibraryLock(library, block_name='A', safe_to_release=lambda: False) as lease: pass script = ('import sys; from cbb_refresh_verify.library_lock import LibraryLock; ' 'lease=LibraryLock(sys.argv[1],checkpoint=False); lease.__enter__(); lease.__exit__()') try: blocked = subprocess.run([sys.executable, '-c', script, str(library)], capture_output=True) assert blocked.returncode != 0 result = residual_sessions.release_residual_sessions( {'library': str(library), 'block_names': ['A'], 'sessions': []}, tmp_path/'evidence') assert result['status'] == 'RELEASE_CONFIRMED', result.get('detail') assert result['proof']['proof_block_name'] == 'A' assert result['proof']['lease_state'] == 'RELEASED' assert other.read_bytes() == b'other native address' acquired = subprocess.run([sys.executable, '-c', script, str(library)], capture_output=True) assert acquired.returncode == 0, acquired.stderr assert lease.path.is_file() finally: cleanup(lease) def test_unknown_checkpoint_does_not_require_explicit_other_project_to_exit(tmp_path, monkeypatch): library = library_file(tmp_path) marker = locks.blocker_path(library) marker.write_bytes(b'{legacy unrecognized checkpoint') other = {'pid': 123456, 'name': 'ExpeditionPCB.exe', 'command': f'ExpeditionPCB.exe "{tmp_path}/Other/board.prj"'} monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda *_: [other]) monkeypatch.setattr('cbb_refresh_verify.native_engineering_identity._process_snapshot', lambda: []) result = locks.release_retained_library(library, tmp_path/'evidence') assert result['status'] == 'RELEASE_CONFIRMED' assert result['unknown_checkpoint_archived'] is True assert result['data_recovery_confirmed'] is False def test_slow_release_of_a_does_not_block_b_cached_or_lease_checks(tmp_path, monkeypatch): a, b = library_file(tmp_path, 'A'), library_file(tmp_path, 'B') entered, finish = threading.Event(), threading.Event() with locks.LibraryLock(a, safe_to_release=lambda: False) as lease: pass @contextmanager def slow_proof(*args, **kwargs): entered.set() assert finish.wait(5) yield {'exclusive_files': [str(a)]} monkeypatch.setattr(locks, '_prove_library_released', slow_proof) def inspect_b(): assert not locks.has_retained_library(b) assert session_record.library_available(b) with locks.LibraryLock(b): return True with ThreadPoolExecutor(2) as pool: release = pool.submit(locks.release_retained_library, a, tmp_path/'evidence') try: assert entered.wait(2) check = pool.submit(inspect_b) assert check.result(timeout=.5) finally: finish.set() release.result(5) cleanup(lease) def test_late_observer_cannot_clear_new_operation(tmp_path, monkeypatch): path = tmp_path/'session.json' library = tmp_path/'lib.lmc' session_record.write_session_record(path, {'operation_id': 'old', 'library': str(library)}) key = str(path.absolute()).casefold() entered, finish = threading.Event(), threading.Event() def observe(*args, **kwargs): entered.set() assert finish.wait(3) return {'status': 'RELEASED', 'operation_id': 'old'} monkeypatch.setattr(session_record, 'observe_retained_session', observe) monkeypatch.setattr(session_record, '_observers', {}) monkeypatch.setattr(session_record, '_retained_libraries', {}) monkeypatch.setattr(session_record, '_retained_results', {}) session_record.handoff_session(path, evidence_root=tmp_path) assert entered.wait(2) with session_record._observer_guard: thread = session_record._observers[key][0] session_record._retained_libraries[key] = {session_record._library_key(library)} session_record._retained_results[key] = {'operation_id': 'new', 'status': 'ACTIVE'} finish.set() thread.join(3) assert not session_record.library_available(library) assert session_record.retained_session_states(library)[0]['operation_id'] == 'new' @pytest.mark.parametrize('repair_required', [False, True]) def test_target_address_uses_native_inspection_and_keeps_recovery_separate(tmp_path, monkeypatch, repair_required): library = library_file(tmp_path) work = library.parent/'ReusableBlocksLP/A/Work' database = work/'database' address = database/'cdbsvr/sAddress.adr' address.parent.mkdir(parents=True) address.write_bytes(b'native address retained') (database/'icdb.dat').write_bytes(b'database') project = work/'A.prj' project.write_text('KEY iCDBDir "database"\n') monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda *_: []) def inspect(target, root, **kwargs): assert kwargs['inspection_only'] is True output = f'Loading project file [{project}].\nChecking if project is in use.\n' output += "Project is not in use. Full iCDB Project Backup's functionality is available.\n" if repair_required: output += (f'Project database [{database}] is inconsistent. It has been manually copied while ' "the iCDB Server was running. Please use iCDB Project Backup 'Repair project' functionality to fix this issue.\n") output += 'Backup information loaded correctly.' return dict(status='NOT_IN_USE', repair_required=repair_required, inspection_only=True, repair_requested=False, native_pid=12345, native_exit_code=0, release={'native_exited': True}, project=str(project), database=str(database), output=output) monkeypatch.setattr('cbb_refresh_verify.native_repair.run_native_repair', inspect) with locks.LibraryLock(library, block_name='A', safe_to_release=lambda: False) as lease: pass try: proof = locks.release_retained_library(library, tmp_path/'evidence', block_name='A') assert proof['lease_state'] == 'RELEASED' assert proof['data_recovery_required'] is repair_required assert proof['data_recovery_confirmed'] is False assert proof['resource_scope']['databases'] == [str(database)] assert address.read_bytes() == b'native address retained' assert not locks.has_retained_library(library) finally: cleanup(lease) def test_unknown_checkpoint_does_not_disown_export_server_from_path_alone(tmp_path, monkeypatch): library = library_file(tmp_path) locks.blocker_path(library).write_bytes(b'unknown') other = {'pid': 123456, 'name': 'icdbnetserver.exe', 'command': f'icdbnetserver.exe -icdb "{tmp_path}/Other/database"'} monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda *_: [other]) monkeypatch.setattr('cbb_refresh_verify.native_engineering_identity._process_snapshot', lambda: [other]) with pytest.raises(locks.LibraryBusy): locks.release_retained_library(library, tmp_path/'evidence') def test_file_proof_holds_real_handle_until_context_exit(tmp_path): from cbb_refresh_verify import file_probe library = library_file(tmp_path) with file_probe.hold_release_files(library) as proof: assert proof['exclusive_files'] == [str(library)] with pytest.raises(Exception): handle = win32file.CreateFile(str(library), win32con.GENERIC_WRITE, 0, None, win32con.OPEN_EXISTING, 0, None) handle.Close() handle = win32file.CreateFile(str(library), win32con.GENERIC_WRITE, 0, None, win32con.OPEN_EXISTING, 0, None) handle.Close() @pytest.mark.parametrize('cancel', [False, True]) def test_file_probe_timeout_or_stop_reaps_only_its_helper(tmp_path, monkeypatch, cancel): import time from cbb_refresh_verify import file_probe library = library_file(tmp_path) actual_popen = subprocess.Popen helpers = [] def blocked_probe(command, **kwargs): child = actual_popen([sys.executable, '-c', 'import time; time.sleep(30)'], **kwargs) helpers.append(child) return child monkeypatch.setattr(file_probe.subprocess, 'Popen', blocked_probe) stop = threading.Event() if cancel: threading.Timer(.15, stop.set).start() started = time.monotonic() with pytest.raises((TimeoutError, InterruptedError)): with file_probe.hold_release_files(library, timeout_seconds=.3, stop=stop): pytest.fail('a stalled helper supplied release proof') assert time.monotonic()-started < 3 assert helpers and helpers[0].poll() is not None def test_file_proof_survives_probe_exit_during_parent_commit(tmp_path, monkeypatch): from cbb_refresh_verify import file_probe library = library_file(tmp_path) launch = subprocess.Popen helpers = [] def capture(*args, **kwargs): child = launch(*args, **kwargs) helpers.append(child) return child monkeypatch.setattr(file_probe.subprocess, 'Popen', capture) with file_probe.hold_release_files(library): helpers[0].terminate() helpers[0].wait(3) with pytest.raises(Exception): handle = win32file.CreateFile(str(library), win32con.GENERIC_WRITE, 0, None, win32con.OPEN_EXISTING, 0, None) handle.Close() def test_worker_journal_records_declared_resource_scope_and_operation_identity(tmp_path): import os from types import SimpleNamespace library = library_file(tmp_path) project = library.parent/'ReusableBlocksLP/A/Work/A.prj' pcb = project.parent/'PCB/A.pcb' worker = SimpleNamespace(pid=os.getpid()) path = tmp_path/'session.json' session_record.register_worker_session(worker, dict(session_record_path=str(path), operation_id='operation-123', operation='verify', library=str(library), block='A', project=str(project), pcb=str(pcb))) record = session_record.read_session_record(path, evidence_root=tmp_path) assert record['lease_state'] == 'ACTIVE' assert record['resource_scope']['operation_id'] == 'operation-123' assert record['resource_scope']['projects'] == [str(project)] assert str(pcb.parent/'database') in record['resource_scope']['databases'] assert record['data_recovery_required'] is None def test_replacement_lease_cannot_be_cleared_by_earlier_probe(tmp_path, monkeypatch): library = library_file(tmp_path) with locks.LibraryLock(library, safe_to_release=lambda: False) as lease: pass marker = locks.blocker_path(library) original = marker.read_bytes() @contextmanager def replaced(*args, **kwargs): with locks._guard: locks._owners[lease.key] = {**locks._owners[lease.key], 'lease_id': 'b'*32} yield {'exclusive_files': [str(library)]} monkeypatch.setattr(locks, '_prove_library_released', replaced) try: with pytest.raises(locks.LibraryBusy): locks.release_retained_library(library, tmp_path/'evidence') assert marker.read_bytes() == original assert locks._owners[lease.key]['lease_id'] == 'b'*32 finally: cleanup(lease) def test_multiple_selected_projects_do_not_expand_release_to_unselected_c(tmp_path, monkeypatch): library = library_file(tmp_path) other = library.parent/'ReusableBlocksLP/C/Work/database/cdbsvr/sAddress.adr' other.parent.mkdir(parents=True) other.write_bytes(b'not selected') monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda *_: []) monkeypatch.setattr(residual_sessions, 'query_process_snapshot', lambda: []) monkeypatch.setattr(residual_sessions, '_process_windows', lambda _: {}) with locks.LibraryLock(library, block_name='A', safe_to_release=lambda: False) as lease: pass try: result = residual_sessions.release_residual_sessions( {'library': str(library), 'block_names': ['A', 'B'], 'sessions': []}, tmp_path/'evidence') assert result['status'] == 'RELEASE_CONFIRMED', result.get('detail') assert result['proof']['proof_block_names'] == ['A', 'B'] assert other.read_bytes() == b'not selected' finally: cleanup(lease) @pytest.mark.parametrize('verdict', ['IN_USE', 'UNCONFIRMED', 'NOT_EXITED']) def test_native_inspection_without_release_keeps_lease(tmp_path, monkeypatch, verdict): library = library_file(tmp_path) work = library.parent/'ReusableBlocksLP/A/Work' database = work/'database' address = database/'cdbsvr/sAddress.adr' address.parent.mkdir(parents=True) address.write_bytes(b'keep native address') (database/'icdb.dat').touch() project = work/'A.prj' project.write_text('KEY iCDBDir "database"\n') monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda *_: []) output = f'Loading project file [{project}].\nChecking if project is in use.\nProject is in use.' monkeypatch.setattr('cbb_refresh_verify.native_repair.run_native_repair', lambda *a, **kw: dict(status=verdict, project=str(project), database=str(database), output=output, inspection_only=True, repair_requested=False, repair_required=False, native_pid=123, native_exit_code=0, release={'native_exited': verdict != 'NOT_EXITED'})) with locks.LibraryLock(library, block_name='A', safe_to_release=lambda: False) as lease: pass try: with pytest.raises(locks.LibraryBusy): locks.release_retained_library(library, tmp_path/'evidence', block_name='A') assert locks.has_retained_library(library) assert address.read_bytes() == b'keep native address' finally: cleanup(lease) @pytest.mark.parametrize('invalid_scope', [False, True]) def test_legacy_release_receipt_without_resource_scope_is_rechecked(tmp_path, invalid_scope): library = library_file(tmp_path) session_record.write_session_record(tmp_path/'session.json', {'operation_id': 'legacy', 'library': str(library), 'processes': []}) session_record.write_session_record(tmp_path/'observation-release-old.json', {'operation_id': 'legacy', 'status': 'RELEASED', 'release_proof': {'status': 'RELEASE_CONFIRMED', 'library': str(library), **({'lease_state': 'RELEASED', 'resource_scope': None} if invalid_scope else {})}}) found = session_record.discover_sessions(tmp_path) assert len(found) == 1 assert found[0]['status'] == 'UNCONFIRMED' assert found[0]['resource_scope']['scope_state'] == 'RECHECK_REQUIRED' def test_stalled_transaction_checkpoint_does_not_block_other_library_memory(tmp_path, monkeypatch): from cbb_refresh_verify import management_transaction a, b = library_file(tmp_path, 'A'), library_file(tmp_path, 'B') entered, finish = threading.Event(), threading.Event() original = locks.checkpoint_record def checkpoint(path): if path == locks.blocker_path(a) and threading.current_thread().name.startswith('ThreadPool'): entered.set() assert finish.wait(5) return original(path) with locks.LibraryLock(a): monkeypatch.setattr(locks, 'checkpoint_record', checkpoint) with ThreadPoolExecutor(2) as pool: transaction = pool.submit(management_transaction.current_lease, a) try: assert entered.wait(2) check = pool.submit(locks.has_retained_library, b) assert check.result(.5) is False finally: finish.set() with pytest.raises(ValueError): # This reader is not the lease's owning thread. transaction.result(3) def test_file_proof_holds_address_and_project_binding_against_changes(tmp_path): from cbb_refresh_verify import file_probe library = library_file(tmp_path) database = library.parent/'ReusableBlocksLP/A/Work/database' address = database/'cdbsvr/sAddress.adr' address.parent.mkdir(parents=True) address.write_bytes(b'address') (database/'icdb.dat').touch() project = database.parent/'A.prj' project.write_text('KEY iCDBDir "database"\n') with file_probe.hold_release_files(library): for path in (address, project): with pytest.raises(OSError): path.write_bytes(b'changed binding') assert address.read_bytes() == b'address' assert project.read_text() == 'KEY iCDBDir "database"\n' def test_file_probe_rejects_scope_junction_even_inside_same_library(tmp_path): import _winapi from cbb_refresh_verify import file_probe library = library_file(tmp_path) other = library.parent/'ReusableBlocksLP/B/Work' other.mkdir(parents=True) selected = library.parent/'ReusableBlocksLP/A/Work' selected.parent.mkdir(parents=True) _winapi.CreateJunction(str(other), str(selected)) with pytest.raises(OSError): with file_probe.hold_release_files(library, (selected,)): pytest.fail('scope link silently changed the release target')