Files

160 lines
7.9 KiB
Python

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