"""Review 430: distinguish content evidence, native release and skipped work.""" from dataclasses import replace import pytest from test_backup_recovery import recovery_files from test_management_native_transaction import transaction from test_review414_write_admission import fixture_paths def unknown_identity(monkeypatch): monkeypatch.setattr('cbb_refresh_verify.write_admission.process_identity', lambda pid: dict( pid=pid, created_handle='one', image='viewdraw.exe', owner_sid='user', session_id=1)) def test_headless_admission_skips_without_claiming_an_upload_attempt(tmp_path, monkeypatch): from test_management import FileAdapter from cbb_refresh_verify.management import ManagementRequest, run_management library, source, _ = fixture_paths(tmp_path, monkeypatch) unknown_identity(monkeypatch) adapter = FileAdapter() request = ManagementRequest('add', library, 'One', source=source, auto_verify=False, evidence_dir=tmp_path/'evidence') result = run_management(request, adapter=adapter) assert result.status == 'SKIPPED', result.detail assert result.safe_to_continue assert 'TARGET_NATIVE_OWNER_UNCONFIRMED' in result.detail assert not adapter.calls @pytest.mark.parametrize('prompt', [False, True]) def test_restore_declined_before_install_is_skipped_and_leaves_work_intact(recovery_files, monkeypatch, prompt): from cbb_refresh_verify.backup_recovery import recover_from_backup request, original, source = recovery_files monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda names: [dict( pid=99111, name='viewdraw.exe', executable='viewdraw.exe', command='', parent=0)]) unknown_identity(monkeypatch) result = recover_from_backup(request, source, version_prompt=(lambda choice: choice.choose('skip')) if prompt else None, verifier=lambda *_a, **_kw: pytest.fail('Declined work must not open Mentor')) assert result.status == 'SKIPPED', result.stderr assert result.safe_to_continue assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged' assert not list(original.parent.parent.glob('Work.before-restore-*')) assert '未确认' in result.stderr or '无法确认' in result.stderr def test_idle_without_unknown_clients_probes_only_once(tmp_path, monkeypatch): import win32file from cbb_refresh_verify.backup_recovery import _idle_check library, source, pcb = fixture_paths(tmp_path, monkeypatch) queries, opened = [], [] monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda names: queries.append(names) or []) create = win32file.CreateFile def open_file(path, *args): opened.append(path) return create(path, *args) monkeypatch.setattr(win32file, 'CreateFile', open_file) _idle_check(library, source, pcb) assert len(queries) == 1 assert opened and len(opened) == len(set(opened)) def test_confirmation_rechecks_a_database_that_became_occupied(tmp_path, monkeypatch): import win32con, win32file from cbb_refresh_verify.backup_recovery import _idle_check from cbb_refresh_verify.write_admission import WriteAdmission library, source, pcb = fixture_paths(tmp_path, monkeypatch) unknown_identity(monkeypatch) handles = [] def prompt(choice): handles.append(win32file.CreateFile(str(library), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, 0, None)) choice.choose('continue') try: with pytest.raises(Exception) as error: _idle_check(library, source, pcb, confirmation=WriteAdmission(prompt=prompt), evidence=tmp_path/'evidence', block='One') assert error.value.winerror == 32 finally: for handle in handles: handle.Close() def test_file_proof_does_not_override_confirmed_native_release(transaction, monkeypatch): import cbb_refresh_verify.native_engineering_identity as identity from test_management_native_transaction import execute root, request, state = transaction capture = identity.capture_registration_identity def capture_file(source, evidence_root, **kwargs): if evidence_root.name == 'registered-identity': return identity.IdentityOutcome(None, False, 'file proof unavailable', evidence_root) return capture(source, evidence_root, **kwargs) monkeypatch.setattr(identity, 'capture_registration_identity', capture_file) result = execute(root, request) assert result.status == 'RECOVERY_REQUIRED' assert 'file proof unavailable' in result.detail assert result.safe_to_continue def test_real_file_error_preserves_failed_item_and_allows_an_independent_item(transaction, monkeypatch): import cbb_refresh_verify.native_engineering_identity as identity from cbb_refresh_verify.management import run_management_batch from cbb_refresh_verify.native_management import _OwnedFixtureManagementAdapter root, request, state = transaction assets = identity.asset_identity def read_assets(source, expected_library): if 'ReusableBlocksLP/Block/Work' in source.as_posix(): raise PermissionError('registered file became unreadable') return assets(source, expected_library) monkeypatch.setattr(identity, 'asset_identity', read_assets) adapter = _OwnedFixtureManagementAdapter(root, 'owned') from test_management import project other_source = project(request.source.parent.parent/'other-source', name='Other') for path in (other_source, other_source.parent/'PCB/pcb.prj'): with path.open('a') as stream: stream.write(f'KEY CentralLibrary "{request.library}"\n') results = run_management_batch([request, replace(request, name='Other', source=other_source)], adapter=adapter, idle_check=lambda *_: None) assert [r.status for r in results] == ['RECOVERY_REQUIRED', 'UPLOADED'] assert all(r.safe_to_continue for r in results) assert 'registered file became unreadable' in results[0].detail from test_management_native_transaction import execute replay = execute(root, request) assert replay.status == 'BLOCKED' def test_unreleased_native_owner_never_reaches_file_proof(transaction, monkeypatch): import cbb_refresh_verify.native_management as native import cbb_refresh_verify.native_engineering_identity as identity from test_management_native_transaction import execute root, request, state = transaction worker = native.NativeManagementAdapter._worker capture = identity.capture_registration_identity def native_worker(adapter, job, evidence): result = worker(adapter, job, evidence) if evidence.name == 'reopen-aligned': result['safe_to_continue'] = False return result def capture_file(source, evidence_root, **kwargs): if evidence_root.name == 'registered-identity': pytest.fail('Unreleased native owner cannot be replaced by a file-only proof') return capture(source, evidence_root, **kwargs) monkeypatch.setattr(native.NativeManagementAdapter, '_worker', native_worker) monkeypatch.setattr(identity, 'capture_registration_identity', capture_file) result = execute(root, request) assert result.status == 'RECOVERY_REQUIRED' assert not result.safe_to_continue @pytest.mark.parametrize('status,message', [('SKIPPED', '恢复已跳过'), ('CANCELLED', '恢复已取消')]) def test_restore_dialog_reports_unexecuted_work_without_a_failure_label(qtbot, tmp_path, status, message): from cbb_refresh_verify.ui.backup_recovery_dialog import BackupRecoveryDialog from cbb_refresh_verify.verify_runner import VerifyResult dialog = BackupRecoveryDialog(['One'], lambda _: None) qtbot.addWidget(dialog) dialog._result('One', VerifyResult(status, stderr='reason retained')) assert message in dialog.status_label.text() assert 'reason retained' in dialog.status_label.text() assert '恢复未通过' not in dialog.status_label.text()