244 lines
12 KiB
Python
244 lines
12 KiB
Python
from cbb_refresh_verify.ui import timed_prompt
|
|
from dataclasses import replace
|
|
from pathlib import Path
|
|
from threading import Event
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
from PySide6.QtCore import QTimer
|
|
from PySide6.QtWidgets import QMessageBox
|
|
|
|
from cbb_refresh_verify.management import Capability, ManagementRequest, ManagementResult
|
|
from cbb_refresh_verify.verify_runner import VerifyResult
|
|
|
|
|
|
def failed_repair(path, *, safe=False):
|
|
return VerifyResult('FAIL', error_category='CBB_REIMPORT_REQUIRED',
|
|
stderr='Back Annotation is not allowed on verified (or once verified) Reusable Blocks.',
|
|
evidence_path=path, safe_to_continue=safe,
|
|
recovery_attempts=({'native_status': 'REPAIRED', 'status': 'REPAIR_VALIDATION_FAILED',
|
|
'validation_passed': False},))
|
|
|
|
|
|
def recovery_window(qtbot, tmp_path, monkeypatch, result=None):
|
|
from test_ui_filters import load_window
|
|
adapter = SimpleNamespace(capabilities=lambda: {op: Capability(True, 'available')
|
|
for op in ('add', 'update', 'remove')})
|
|
result = result or failed_repair(tmp_path/'maintenance/result.json')
|
|
window = load_window(qtbot, tmp_path, monkeypatch, management_adapter=adapter,
|
|
verifier=lambda _: result, status_refresher=lambda names, path: {n: 'PENDING' for n in names})
|
|
window.search_edit.setText('Beta')
|
|
window.repair_icdb_all()
|
|
qtbot.waitUntil(lambda: not window._icdb_active())
|
|
return window, result
|
|
|
|
|
|
def test_failed_repair_offers_copy_import_bound_to_failed_target(qtbot, tmp_path, monkeypatch):
|
|
window, failed = recovery_window(qtbot, tmp_path, monkeypatch)
|
|
assert '副本' in window.summary.text()
|
|
action = next(b for b in window.summary.buttons() if '副本' in b.text())
|
|
window.search_edit.setText('Alpha')
|
|
window.select_visible_button.click()
|
|
action.click()
|
|
dialog = window.management_dialog
|
|
requests = dialog.requests()
|
|
assert len(requests) == 1 and requests[0].name == 'Beta'
|
|
assert requests[0].partition == 'Power' and requests[0].operation == 'update'
|
|
assert requests[0].source is None and requests[0].auto_verify
|
|
assert '修复未完成' in dialog.status_label.text()
|
|
assert '手动备份' in dialog.status_label.text()
|
|
assert str(failed.evidence_path) in dialog.output.toPlainText()
|
|
dialog.reject()
|
|
assert failed.status == 'FAIL'
|
|
assert window.reimport_button.isEnabled()
|
|
|
|
|
|
def test_declining_reimport_confirmation_does_not_check_release_or_write(qtbot, tmp_path, monkeypatch):
|
|
import cbb_refresh_verify.library_lock as locks
|
|
window, _ = recovery_window(qtbot, tmp_path, monkeypatch)
|
|
window.summary.close()
|
|
window.reimport_button.click()
|
|
dialog = window.management_dialog
|
|
source = tmp_path/'copy/test.prj'; source.parent.mkdir(); source.touch()
|
|
dialog.add_sources([source])
|
|
monkeypatch.setattr(locks, 'release_retained_library', lambda *a: pytest.fail('unconfirmed release'))
|
|
confirmations = []
|
|
monkeypatch.setattr(timed_prompt, 'question', lambda *a, **kw:
|
|
confirmations.append(a[2]) or QMessageBox.No)
|
|
dialog.execute_button.click()
|
|
assert not dialog.busy and not dialog.executed
|
|
assert 'Beta' in confirmations[0] and str(source) in confirmations[0]
|
|
assert '副本' in confirmations[0] and '先移除' in confirmations[0]
|
|
dialog.reject()
|
|
|
|
|
|
@pytest.mark.parametrize('result', [VerifyResult('CHECKED'), VerifyResult('PASS', library_flag='GREEN'),
|
|
VerifyResult('BLOCKED', error_category='ICDB_DATABASE_IN_USE', safe_to_continue=False),
|
|
VerifyResult('FAIL', stderr='unknown error')])
|
|
def test_no_reimport_offer_for_unconfirmed_diagnosis_or_success(qtbot, tmp_path, monkeypatch, result):
|
|
window, _ = recovery_window(qtbot, tmp_path, monkeypatch, result)
|
|
assert not window.reimport_button.isVisible()
|
|
assert not any('副本' in b.text() for b in window.summary.buttons())
|
|
|
|
|
|
def test_changing_library_invalidates_old_reimport_offer(qtbot, tmp_path, monkeypatch):
|
|
window, _ = recovery_window(qtbot, tmp_path, monkeypatch)
|
|
old_action = next(b for b in window.summary.buttons() if '副本' in b.text())
|
|
window.lmc_edit.setText('another.lmc')
|
|
old_action.click()
|
|
assert not getattr(window, 'management_dialog', None)
|
|
assert not window.reimport_button.isVisible()
|
|
|
|
|
|
def request(tmp_path):
|
|
library = tmp_path/'lib/mentor.lmc'; library.parent.mkdir(); library.touch()
|
|
source = tmp_path/'copy/Block.prj'; source.parent.mkdir(); source.touch()
|
|
return ManagementRequest('update', library, 'Block', source=source, evidence_dir=tmp_path/'management')
|
|
|
|
|
|
def test_release_failure_preserves_failure_and_never_dispatches_management(tmp_path, monkeypatch):
|
|
from cbb_refresh_verify.reimport_recovery import run_reimport_recovery
|
|
import cbb_refresh_verify.library_lock as locks
|
|
import cbb_refresh_verify.management as management
|
|
req = request(tmp_path)
|
|
monkeypatch.setattr(management, 'source_project', lambda *a: (req.source, req.source, 'Block'))
|
|
def denied(*a): raise locks.LibraryBusy('PCB still active: 123')
|
|
monkeypatch.setattr(locks, 'release_retained_library', denied)
|
|
monkeypatch.setattr(management, 'run_management_batch', lambda *a, **kw: pytest.fail('unsafe write'))
|
|
results = run_reimport_recovery([req], previous_evidence={'Block': tmp_path/'old/result.json'},
|
|
evidence_dir=tmp_path/'reimport')
|
|
assert results[0].status == 'BLOCKED' and not results[0].safe_to_continue
|
|
assert '123' in results[0].detail
|
|
import json
|
|
record = json.loads(results[0].evidence_path.read_text('utf-8'))
|
|
assert record['previous_evidence']['Block'] == str(tmp_path/'old/result.json')
|
|
assert record['stage'] == 'release_failed'
|
|
|
|
|
|
def test_cancel_during_release_prevents_import(tmp_path, monkeypatch):
|
|
from cbb_refresh_verify.reimport_recovery import run_reimport_recovery
|
|
import cbb_refresh_verify.library_lock as locks
|
|
import cbb_refresh_verify.management as management
|
|
req = request(tmp_path); stop = Event()
|
|
monkeypatch.setattr(management, 'source_project', lambda *a: (req.source, req.source, 'Block'))
|
|
def release(*a):
|
|
stop.set()
|
|
return {'status': 'RELEASE_CONFIRMED', 'evidence_path': 'release.json'}
|
|
monkeypatch.setattr(locks, 'release_retained_library', release)
|
|
monkeypatch.setattr(management, 'run_management_batch', lambda *a, **kw: pytest.fail('cancelled write'))
|
|
results = run_reimport_recovery([req], previous_evidence={'Block': 'old.json'},
|
|
evidence_dir=tmp_path/'reimport', stop=stop)
|
|
assert results == []
|
|
|
|
|
|
@pytest.mark.parametrize('uploaded_status', ['UPLOADED', 'UPLOADED_VERIFY_FAILED', 'UPLOADED_VERIFIED'])
|
|
def test_copy_recovery_keeps_native_management_outcome_and_original_evidence(tmp_path, monkeypatch, uploaded_status):
|
|
from cbb_refresh_verify.reimport_recovery import run_reimport_recovery
|
|
import cbb_refresh_verify.library_lock as locks
|
|
import cbb_refresh_verify.management as management
|
|
import json
|
|
req = request(tmp_path)
|
|
old = tmp_path/'old.json'; old.write_text('{"status":"FAIL"}', encoding='utf-8')
|
|
before = old.read_bytes()
|
|
monkeypatch.setattr(management, 'source_project', lambda *a: (req.source, req.source, 'Block'))
|
|
monkeypatch.setattr(locks, 'release_retained_library', lambda *a:
|
|
{'status': 'RELEASE_CONFIRMED', 'evidence_path': 'release.json'})
|
|
expected = ManagementResult('update', req.library, req.name, req.partition, req.source,
|
|
True, 'complete', uploaded_status, True)
|
|
monkeypatch.setattr(management, 'run_management_batch', lambda *a, **kw: [expected])
|
|
results = run_reimport_recovery([req], previous_evidence={'Block': str(old)},
|
|
evidence_dir=tmp_path/'reimport')
|
|
assert results == [expected] and old.read_bytes() == before
|
|
record = json.loads(next((tmp_path/'reimport').glob('*/recovery.json')).read_text('utf-8'))
|
|
assert record['original_repair_succeeded'] is False
|
|
assert record['results'][0]['status'] == uploaded_status and record['version_review_required']
|
|
|
|
|
|
def test_incomplete_copy_never_releases_or_removes_target(tmp_path, monkeypatch):
|
|
from cbb_refresh_verify.reimport_recovery import run_reimport_recovery
|
|
import cbb_refresh_verify.library_lock as locks
|
|
req = request(tmp_path) # Empty PRJ is deliberately incomplete.
|
|
monkeypatch.setattr(locks, 'release_retained_library', lambda *a: pytest.fail('incomplete source'))
|
|
results = run_reimport_recovery([req], previous_evidence={'Block': 'old.json'},
|
|
evidence_dir=tmp_path/'reimport')
|
|
assert results[0].status == 'BLOCKED' and results[0].stage == 'preflight'
|
|
|
|
|
|
def test_recovery_uses_background_release_then_existing_management(qtbot, tmp_path, monkeypatch):
|
|
from cbb_refresh_verify.ui.management_dialog import ManagementDialog
|
|
import cbb_refresh_verify.library_lock as locks
|
|
import cbb_refresh_verify.management as management
|
|
req = request(tmp_path); entered, finish = Event(), Event(); calls = []
|
|
monkeypatch.setattr(management, 'source_project', lambda *a: (req.source, req.source, 'Block'))
|
|
def release(*a):
|
|
entered.set(); assert finish.wait(5)
|
|
calls.append('release')
|
|
return {'status': 'RELEASE_CONFIRMED', 'evidence_path': 'release.json'}
|
|
monkeypatch.setattr(locks, 'release_retained_library', release)
|
|
def run(items, **kw):
|
|
calls.append('management')
|
|
return [ManagementResult('update', req.library, req.name, req.partition, req.source,
|
|
True, 'complete', 'UPLOADED_VERIFIED', True)]
|
|
monkeypatch.setattr(management, 'run_management_batch', run)
|
|
monkeypatch.setattr(timed_prompt, 'question', lambda *a, **kw: QMessageBox.Yes)
|
|
dialog = ManagementDialog([req], recovery_from={'Block': 'old.json'})
|
|
qtbot.addWidget(dialog)
|
|
ticks = []
|
|
timer = QTimer(); timer.setInterval(10); timer.timeout.connect(lambda: ticks.append(1)); timer.start()
|
|
try:
|
|
dialog.execute_button.click()
|
|
qtbot.waitUntil(entered.is_set)
|
|
qtbot.waitUntil(lambda: len(ticks) >= 3)
|
|
assert calls == [] and dialog.busy
|
|
finally:
|
|
finish.set()
|
|
qtbot.waitUntil(lambda: not dialog.busy)
|
|
timer.stop()
|
|
assert calls == ['release', 'management']
|
|
assert '版本待核对' in dialog.status_label.text()
|
|
|
|
|
|
def test_recovery_dialog_keeps_internal_details_in_optional_log(qtbot, tmp_path):
|
|
from cbb_refresh_verify.ui.management_dialog import ManagementDialog
|
|
req = request(tmp_path)
|
|
dialog = ManagementDialog([req], recovery_from={'Block': 'old-result.json'})
|
|
qtbot.addWidget(dialog); dialog.show()
|
|
assert dialog.output.isHidden()
|
|
assert not any(word in dialog.status_label.text() for word in ('原生', '证据', '检查点', '记录保留'))
|
|
detail = 'OWNER_QUERY_TIMEOUT: diagnostic internals'
|
|
result = ManagementResult('update', req.library, req.name, req.partition, req.source,
|
|
True, 'release_check', 'BLOCKED', False, detail, tmp_path/'recovery.json')
|
|
dialog._result([result])
|
|
assert detail not in dialog.status_label.text()
|
|
assert '日志' in dialog.status_label.text()
|
|
dialog.logs_button.click()
|
|
assert dialog.output.isVisible() and detail in dialog.output.toPlainText()
|
|
|
|
|
|
def test_main_stop_during_recovery_release_cancels_import(qtbot, tmp_path, monkeypatch):
|
|
import cbb_refresh_verify.library_lock as locks
|
|
import cbb_refresh_verify.management as management
|
|
window, _ = recovery_window(qtbot, tmp_path, monkeypatch)
|
|
window.summary.close(); window.reimport_button.click()
|
|
dialog = window.management_dialog
|
|
source = tmp_path/'copy/source.prj'; source.parent.mkdir(); source.touch()
|
|
dialog.add_sources([source])
|
|
monkeypatch.setattr(management, 'source_project', lambda *a: (source, source, 'Beta'))
|
|
entered, finish = Event(), Event()
|
|
def release(*args):
|
|
entered.set(); assert finish.wait(5)
|
|
return {'status': 'RELEASE_CONFIRMED', 'evidence_path': 'release.json'}
|
|
monkeypatch.setattr(locks, 'release_retained_library', release)
|
|
dispatched = []
|
|
monkeypatch.setattr(management, 'run_management_batch', lambda *a, **kw: dispatched.append(a) or [])
|
|
dialog.execute_button.click()
|
|
try:
|
|
qtbot.waitUntil(entered.is_set)
|
|
window.stop_button.click()
|
|
assert dialog.stop.is_set()
|
|
finally:
|
|
finish.set(); qtbot.waitUntil(lambda: not dialog.busy)
|
|
dialog.reject()
|
|
assert dispatched == []
|
|
|