from concurrent.futures import ThreadPoolExecutor import pytest import win32con import win32file def test_library_lock_excludes_other_thread_and_uploader_but_reenters(tmp_path): from cbb_refresh_verify.library_lock import LibraryLock, LibraryBusy library = tmp_path/'test.lmc' library.write_bytes(b'fixture') with LibraryLock(library) as lock: assert lock.path.name == '.test.cbb-upload.lock' with LibraryLock(library): assert lock.snapshot_bytes() with pytest.raises(Exception): win32file.CreateFile(str(lock.path), win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None, win32con.OPEN_ALWAYS, 0, None) def competing(): with pytest.raises(LibraryBusy): with LibraryLock(library): pass with ThreadPoolExecutor(1) as pool: pool.submit(competing).result() assert lock.path.exists() with LibraryLock(library): pass def test_complete_copy_reads_owned_lock_without_reopening(tmp_path): from cbb_refresh_verify.library_lock import LibraryLock from cbb_refresh_verify.scoped_manifest import copy_verified source = tmp_path/'library' source.mkdir() library = source/'test.lmc' library.write_bytes(b'fixture') with LibraryLock(library) as lock: expected = lock.snapshot_bytes() copy_verified(source, tmp_path/'snapshot') assert (tmp_path/'snapshot'/lock.path.name).read_bytes() == expected def test_external_lock_never_gets_snapshot_exception(tmp_path): from cbb_refresh_verify.scoped_manifest import copy_verified source = tmp_path/'library' source.mkdir() path = source/'.test.cbb-upload.lock' path.write_bytes(b'external') handle = win32file.CreateFile(str(path), win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None, win32con.OPEN_EXISTING, 0, None) try: with pytest.raises(OSError): copy_verified(source, tmp_path/'snapshot') finally: handle.Close() def test_verification_refuses_uploader_exclusive_lock_before_native_work(tmp_path, monkeypatch): import cbb_refresh_verify.verify_runner as runner library = tmp_path/'lib.lmc' library.touch() lock = tmp_path/'.lib.cbb-upload.lock' handle = win32file.CreateFile(str(lock), win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None, win32con.OPEN_ALWAYS, 0, None) monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: pytest.fail('native work bypassed lock')) try: result = runner.run_verify(runner.VerifyRequest(library, 'Block', tmp_path/'out')) assert result.status == 'BLOCKED' and not result.safe_to_continue finally: handle.Close() def test_unsafe_verify_retains_lease_and_persistent_blocker(tmp_path, monkeypatch): import cbb_refresh_verify.verify_runner as runner import cbb_refresh_verify.library_lock as locks library = tmp_path/'lib.lmc'; library.touch() monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: runner.VerifyResult('FAIL', safe_to_continue=False)) result = runner.run_verify(runner.VerifyRequest(library, 'Block', tmp_path/'out')) assert not result.safe_to_continue assert locks.blocker_path(library).is_file() with pytest.raises(locks.LibraryBusy): with locks.LibraryLock(library): pass # Simulate OS handle loss on process exit; persistent marker still blocks. with locks._guard: owner = locks._owners.pop(str((tmp_path/'.lib.cbb-upload.lock').resolve()).casefold(), None) if owner: owner['handle'].Close() with pytest.raises(locks.LibraryBusy): with locks.LibraryLock(library): pass def test_explicit_release_requires_fresh_proof_and_never_deletes_sidecar(tmp_path, monkeypatch): import cbb_refresh_verify.library_lock as locks library = tmp_path/'library/lib.lmc'; library.parent.mkdir(); library.touch() with locks.LibraryLock(library, safe_to_release=lambda: False) as lease: pass try: def denied(*a): raise ValueError('native owner remains') monkeypatch.setattr(locks, '_prove_library_released', denied) with pytest.raises(ValueError, match='native owner'): locks.release_retained_library(library, tmp_path/'release') assert locks.blocker_path(library).is_file() from contextlib import contextmanager @contextmanager def proof(*a): yield {'native_owners': [], 'addresses': [], 'exclusive_files': [str(library)]} monkeypatch.setattr(locks, '_prove_library_released', proof) result = locks.release_retained_library(library, tmp_path/'release') assert result['status'] == 'RELEASE_CONFIRMED' assert lease.path.is_file() and not locks.blocker_path(library).exists() with locks.LibraryLock(library): pass finally: with locks._guard: owner = locks._owners.pop(str(lease.path.resolve()).casefold(), None) if owner: owner['handle'].Close() def test_release_proof_checks_addresses_and_exclusive_databases(tmp_path, monkeypatch): import cbb_refresh_verify.library_lock as locks import win32com.client from types import SimpleNamespace monkeypatch.setattr(win32com.client, 'GetObject', lambda *_: SimpleNamespace(ExecQuery=lambda *_: [])) library = tmp_path/'lib.lmc'; library.touch() address = tmp_path/'database/cdbsvr/sAddress.adr'; address.parent.mkdir(parents=True) address.touch() with pytest.raises(locks.LibraryBusy): with locks._prove_library_released(library): pass address.unlink() # Test-created empty marker, never a native address file. handle = win32file.CreateFile(str(library), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, 0, None) try: with pytest.raises(Exception): with locks._prove_library_released(library): pass finally: handle.Close() with locks._prove_library_released(library) as proof: assert proof['exclusive_files'] == [str(library)] def test_public_verify_initializes_com_in_its_operation_thread(tmp_path, monkeypatch): import ctypes import cbb_refresh_verify.verify_runner as runner library = tmp_path/'lib.lmc'; library.touch() def serialized(*a, **k): apartment, qualifier = ctypes.c_int(), ctypes.c_int() ole32 = ctypes.WinDLL('ole32') ole32.CoGetApartmentType.argtypes = [ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)] initialized = ole32.CoGetApartmentType(ctypes.byref(apartment), ctypes.byref(qualifier)) == 0 return runner.VerifyResult('PASS' if initialized else 'FAIL', stderr='COM apartment check') monkeypatch.setattr(runner, '_run_verify_serialized', serialized) with ThreadPoolExecutor(1) as pool: result = pool.submit(runner.run_verify, runner.VerifyRequest(library, 'Block', tmp_path/'out')).result() assert result.status == 'PASS' @pytest.mark.parametrize('mode,expected', [(0, 1), (2, 0)]) def test_public_verify_preserves_existing_apartment(tmp_path, monkeypatch, mode, expected): import ctypes, pythoncom import cbb_refresh_verify.verify_runner as runner library = tmp_path/'lib.lmc'; library.touch() monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: runner.VerifyResult('PASS')) def existing_mta(): pythoncom.CoInitializeEx(mode) try: runner.run_verify(runner.VerifyRequest(library, 'Block', tmp_path/'out')) apartment, qualifier = ctypes.c_int(), ctypes.c_int() ole32 = ctypes.WinDLL('ole32') ole32.CoGetApartmentType.argtypes = [ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)] result = ole32.CoGetApartmentType(ctypes.byref(apartment), ctypes.byref(qualifier)) return result, apartment.value finally: pythoncom.CoUninitialize() with ThreadPoolExecutor(1) as pool: assert pool.submit(existing_mta).result() == (0, expected) def test_nested_snapshot_retains_runtime_checkpoint_bytes_without_semantic_conflicts(tmp_path): import cbb_refresh_verify.library_lock as locks from cbb_refresh_verify.scoped_manifest import copy_verified, build_manifest, ManifestScope library = tmp_path/'library/lib.lmc'; library.parent.mkdir(); library.write_bytes(b'library') scope = ManifestScope.library('Block', library.name) with locks.LibraryLock(library) as lease: before = copy_verified(library.parent, tmp_path/'snapshot', scope=scope) marker = locks.blocker_path(library) assert (tmp_path/'snapshot'/marker.name).read_bytes() == marker.read_bytes() with locks.LibraryLock(library): owner = locks._owners[lease.key] locks._persist_blocker(library, lease_id=owner['lease_id']) assert build_manifest(library.parent, scope=scope) == before assert not marker.exists() and lease.path.exists() def test_arbitrary_guard_filename_is_preserved_and_primary(tmp_path, monkeypatch): import cbb_refresh_verify.library_lock as locks from cbb_refresh_verify.scoped_manifest import build_manifest, ManifestScope library = tmp_path/'library/lib.lmc'; library.parent.mkdir(); library.touch() marker = locks.blocker_path(library); marker.write_bytes(b'{not a guard record') with pytest.raises(locks.LibraryBusy): with locks.LibraryLock(library): pass manifest = build_manifest(library.parent, scope=ManifestScope.library('Block', library.name)) assert marker.name in manifest['files'] from contextlib import contextmanager @contextmanager def proof(*a): yield {'native_owners': [], 'addresses': [], 'exclusive_files': [str(library)]} monkeypatch.setattr(locks, '_prove_library_released', proof) with pytest.raises(locks.LibraryBusy): locks.release_retained_library(library, tmp_path/'release') assert marker.read_bytes() == b'{not a guard record'