160 lines
7.9 KiB
Python
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()
|