Files
cbb-refresh-verify-795/tests/test_all_buttons.py
T

574 lines
25 KiB
Python

"""Click every owned control; use real dialogs and controlled native outcomes."""
from pathlib import Path
from threading import Event
from types import SimpleNamespace
import json
import pytest
from PySide6.QtCore import Qt
from PySide6.QtWidgets import QMessageBox, QPushButton, QTextEdit
from shiboken6 import isValid
from button_simulation import modal_click, press, tab
from cbb_refresh_verify.management import Capability, ManagementRequest, ManagementResult
from cbb_refresh_verify.models import CbbRecord, LibraryReadResult
from cbb_refresh_verify.verify_runner import VerifyRequest, VerifyResult
@pytest.fixture
def controls(qtbot, tmp_path, monkeypatch, qapp):
import cbb_refresh_verify.ui.main_window as ui
from cbb_refresh_verify import library_lock
old_native = qapp.testAttribute(Qt.AA_DontUseNativeDialogs)
qapp.setAttribute(Qt.AA_DontUseNativeDialogs, True)
library = tmp_path/'library.lmc'
library.touch()
source = tmp_path/'Beta.prj'
source.write_text('KEY iCDBDir "database"\n', encoding='utf-8')
state = SimpleNamespace(library=library, source=source, reads=[], runs=[], opened=[],
entered=Event(), finish=Event(), native=[], result=None)
state.finish.set()
records = (CbbRecord('Ready', 'Power', status='READY'),
CbbRecord('Beta', 'Power', status='PENDING'), CbbRecord('Gamma', 'Analog', status='UNKNOWN'))
lease = SimpleNamespace(mentor_path=library, display_path=library, drive='', remote_root='',
close=lambda: None, retain_for_recovery=lambda: None)
def verify(request):
state.runs.append(request)
state.entered.set()
assert state.finish.wait(5)
return state.result or VerifyResult('CHECKED' if request.maintenance else 'PASS')
monkeypatch.setattr(ui, 'preflight_skip_reason', lambda *_: None)
monkeypatch.setattr(ui.os, 'startfile', lambda path: state.opened.append(Path(path)))
monkeypatch.setattr(library_lock, 'inspect_residual_sessions',
lambda path: dict(library=str(path), sessions=[]))
adapter = SimpleNamespace(capabilities=lambda: {op: Capability(True, 'validated fixture')
for op in ('add', 'update', 'remove')})
window = ui.MainWindow(reader=lambda path: (state.reads.append(path) or LibraryReadResult(records)),
verifier=verify, data_root=tmp_path/'data', path_lease_factory=lambda _: lease,
status_refresher=lambda names, _: {name:'PENDING' for name in names}, management_adapter=adapter)
state.window = window
window.show()
window.lmc_edit.setText(str(library))
press(qtbot, window.load_button)
qtbot.waitUntil(lambda: not window.busy)
yield state
state.finish.set()
window.stop.set()
if window._icdb_active():
window.icdb_task.cancel()
window.native_queue.wake()
if window._closing:
qtbot.waitUntil(lambda: not isValid(window) or not window.isVisible())
if isValid(window):
window.deleteLater()
qtbot.waitUntil(lambda: not isValid(window))
qapp.setAttribute(Qt.AA_DontUseNativeDialogs, old_native)
return
dialog = getattr(window, 'management_dialog', None)
if dialog is not None and isValid(dialog):
dialog.stop.set()
qtbot.waitUntil(lambda: not window.busy or (dialog is not None and not dialog.busy))
for child in window.findChildren(QMessageBox):
if isValid(child):
child.close()
for name in ('management_dialog', 'backup_dialog', 'release_dialog'):
child = getattr(window, name, None)
if child is not None and isValid(child):
qtbot.waitUntil(lambda child=child: not child.busy)
child.close()
qtbot.waitUntil(lambda: not window.busy and not window._icdb_active())
window.close()
qtbot.waitUntil(lambda: not isValid(window) or not window.isVisible())
if isValid(window):
window.deleteLater()
qtbot.waitUntil(lambda: not isValid(window))
qapp.setAttribute(Qt.AA_DontUseNativeDialogs, old_native)
def test_main_navigation_selection_and_toggles(controls, qtbot):
w = controls.window
for index in (2, 1, 0, 2, 0):
tab(qtbot, w, index)
press(qtbot, w.select_visible_button)
assert len(w.selected_records()) == 3
press(qtbot, w.clear_selection_button)
assert w.selected_records() == ()
press(qtbot, w.advanced_toggle)
assert w.advanced_panel.isVisible()
original = w.native_lm_verify_check.isChecked()
press(qtbot, w.native_lm_verify_check)
assert w.native_lm_verify_check.isChecked() != original
press(qtbot, w.native_lm_verify_check)
press(qtbot, w.advanced_toggle)
assert not w.advanced_panel.isVisible()
press(qtbot, w.runtime_log_toggle)
assert w.output.isVisible()
press(qtbot, w.runtime_log_toggle)
assert not w.output.isVisible()
@pytest.mark.parametrize('cancel', [True, False])
def test_main_library_chooser_real_open_and_cancel(controls, qtbot, cancel):
w = controls.window
before = len(controls.reads)
with modal_click(qtbot, file=None if cancel else controls.library, cancel_file=cancel):
press(qtbot, w.browse_button)
qtbot.waitUntil(lambda: not w.busy)
assert len(controls.reads) == before + (0 if cancel else 1)
press(qtbot, w.load_button)
qtbot.waitUntil(lambda: not w.busy)
assert len(controls.reads) == before + (1 if cancel else 2)
def test_main_logs_and_evidence_buttons_open_the_correct_paths(controls, qtbot):
w = controls.window
press(qtbot, w.logs_button)
evidence = controls.library.parent/'evidence'
evidence.mkdir()
w.recovery_path = evidence
w.recovery_button.setEnabled(True)
press(qtbot, w.recovery_button)
assert controls.opened == [w.data_root/'logs', evidence]
@pytest.mark.parametrize('attribute', ['selected_batch_button', 'batch_button', 'icdb_repair_button'])
@pytest.mark.parametrize('answer', [QMessageBox.No, QMessageBox.Yes])
def test_main_check_buttons_have_real_confirm_and_cancel_paths(controls, qtbot, attribute, answer):
w = controls.window
if attribute == 'icdb_repair_button':
tab(qtbot, w, 1)
w.search_edit.setText('Beta')
press(qtbot, w.select_visible_button)
with modal_click(qtbot, answer):
press(qtbot, getattr(w, attribute))
qtbot.waitUntil(lambda: not w.busy and not w._icdb_active())
assert [request.block_name for request in controls.runs] == ([] if answer == QMessageBox.No else ['Beta'])
if controls.runs:
assert controls.runs[0].auto_repair is False
summary = w.summary
details = next((b for b in summary.findChildren(QPushButton) if 'Details' in b.text()), None)
assert details is not None
press(qtbot, details)
assert summary.findChild(QTextEdit).isVisible()
press(qtbot, summary.button(QMessageBox.Close))
assert not isValid(summary) or not summary.isVisible()
@pytest.mark.parametrize('background', [True, False])
def test_main_stop_buttons_stop_additional_items(controls, qtbot, background):
w = controls.window
controls.finish.clear()
if background:
tab(qtbot, w, 1)
button = w.icdb_repair_button if background else w.batch_button
try:
with modal_click(qtbot, QMessageBox.Yes):
press(qtbot, button)
qtbot.waitUntil(controls.entered.is_set)
stop = w.icdb_stop_button if background else w.stop_button
press(qtbot, stop)
assert (w.icdb_task.stop if background else w.stop).is_set()
finally:
controls.finish.set()
qtbot.waitUntil(lambda: not w.busy and not w._icdb_active())
assert [request.block_name for request in controls.runs] == ['Beta']
@pytest.mark.parametrize('operation', ['add', 'update', 'remove'])
def test_main_management_buttons_open_the_requested_operation(controls, qtbot, operation):
w = controls.window
tab(qtbot, w, 2)
w.search_edit.setText('Beta')
press(qtbot, w.select_visible_button)
press(qtbot, getattr(w, operation+'_button'))
dialog = w.management_dialog
assert dialog.operation == operation and w.busy
if operation != 'add':
assert [request.name for request in dialog.requests()] == ['Beta']
press(qtbot, dialog.close_button)
qtbot.waitUntil(lambda: not w.busy)
def test_main_backup_restore_and_release_entries(controls, qtbot):
w = controls.window
tab(qtbot, w, 1)
w.search_edit.setText('Beta')
press(qtbot, w.select_visible_button)
press(qtbot, w.backup_restore_button)
assert w.backup_dialog.block_combo.currentText() == 'Beta'
press(qtbot, w.backup_dialog.close_button)
tab(qtbot, w, 2)
press(qtbot, w.release_library_button)
qtbot.waitUntil(lambda: not w.release_dialog.busy)
assert w.release_dialog.plan['library'] == str(controls.library)
press(qtbot, w.release_dialog.close_button)
qtbot.waitUntil(lambda: not w.busy)
def test_native_backup_entry_starts_once_and_reenables_after_receipt(controls, qtbot):
w = controls.window
tab(qtbot, w, 1)
w.search_edit.setText('Beta')
press(qtbot, w.select_visible_button)
job = controls.library.parent/'request.json'
job.write_text('{}', encoding='utf-8')
ended = Event()
session = SimpleNamespace(library=controls.library, block='Beta', job=job,
process=SimpleNamespace(poll=lambda: 0 if ended.is_set() else None))
w.native_backup_launcher = lambda request: (controls.native.append(request) or session)
press(qtbot, w.native_backup_button)
qtbot.waitUntil(lambda: not w.busy)
for _ in range(5):
qtbot.mouseClick(w.native_backup_button, Qt.LeftButton)
assert len(controls.native) == 1 and not w.native_backup_button.isEnabled()
job.with_name('result.json').write_text(json.dumps(dict(status='CLOSED', safe_to_continue=True,
library=str(controls.library), block='Beta', restore_confirmed=False)), encoding='utf-8')
ended.set()
qtbot.waitUntil(lambda: w._native_backup_session is None and not w.busy, timeout=3000)
assert w.native_backup_button.isEnabled()
assert 'PASS' not in w.cbb_table.item(w._row_by_name['Beta'], 3).text()
@pytest.mark.parametrize('operation', ['add', 'update'])
@pytest.mark.parametrize('cancel', [True, False])
def test_management_source_chooser_and_auto_verify_toggle(controls, qtbot, operation, cancel):
from cbb_refresh_verify.ui.management_dialog import ManagementDialog
req = ManagementRequest(operation, controls.library, '' if operation == 'add' else 'Beta')
dialog = ManagementDialog([req])
qtbot.addWidget(dialog)
dialog.show()
with modal_click(qtbot, file=None if cancel else controls.source, cancel_file=cancel):
press(qtbot, dialog.sources_button)
assert dialog.table.rowCount() == (0 if operation == 'add' and cancel else 1)
if not cancel:
assert dialog.requests()[0].source == controls.source
checked = dialog.auto_verify.isChecked()
press(qtbot, dialog.auto_verify)
assert dialog.auto_verify.isChecked() != checked
press(qtbot, dialog.logs_button)
assert dialog.output.isVisible()
press(qtbot, dialog.logs_button)
assert not dialog.output.isVisible()
press(qtbot, dialog.close_button)
assert not dialog.isVisible()
def test_management_confirm_cancel_execute_stop_and_repeated_click(controls, qtbot):
from cbb_refresh_verify.ui.management_dialog import ManagementDialog
entered, finish = Event(), Event()
calls = []
def runner(requests, **kwargs):
calls.extend(requests)
entered.set()
assert finish.wait(5)
return [ManagementResult('remove', controls.library, 'Beta', 'Logical-Physical', None,
False, 'complete', 'REMOVED', True)]
dialog = ManagementDialog([ManagementRequest('remove', controls.library, 'Beta')], runner=runner)
qtbot.addWidget(dialog)
dialog.show()
with modal_click(qtbot, QMessageBox.No):
press(qtbot, dialog.execute_button)
assert calls == [] and not dialog.executed
try:
with modal_click(qtbot, QMessageBox.Yes):
press(qtbot, dialog.execute_button)
qtbot.waitUntil(entered.is_set)
for _ in range(5):
qtbot.mouseClick(dialog.execute_button, Qt.LeftButton)
qtbot.mouseClick(dialog.close_button, Qt.LeftButton)
assert len(calls) == 1 and dialog.isVisible()
press(qtbot, dialog.stop_button)
assert dialog.context.stop_after_current.is_set() and not dialog.stop.is_set()
finally:
finish.set()
qtbot.waitUntil(lambda: not dialog.busy)
assert '已移除' in dialog.status_label.text()
press(qtbot, dialog.close_button)
@pytest.mark.parametrize('cancel', [True, False])
def test_recovery_real_source_chooser_and_confirmation_options(controls, qtbot, cancel):
from cbb_refresh_verify.ui.backup_recovery_dialog import BackupRecoveryDialog
calls = []
def recover(request, source, **kwargs):
calls.append((request.block_name, source))
return VerifyResult('PASS')
dialog = BackupRecoveryDialog(['Beta'],
lambda name: VerifyRequest(controls.library, name, controls.library.parent/'evidence'), recoverer=recover)
qtbot.addWidget(dialog)
dialog.show()
with modal_click(qtbot, file=None if cancel else controls.source, cancel_file=cancel):
press(qtbot, dialog.browse_button)
if cancel:
assert dialog.source_edit.text() == ''
else:
assert Path(dialog.source_edit.text()) == controls.source
if cancel:
press(qtbot, dialog.restore_button)
assert '有效' in dialog.status_label.text() and not dialog.busy
else:
with modal_click(qtbot, QMessageBox.No):
press(qtbot, dialog.restore_button)
assert calls == []
with modal_click(qtbot, QMessageBox.Yes):
press(qtbot, dialog.restore_button)
qtbot.waitUntil(lambda: not dialog.busy)
assert calls == [('Beta', controls.source)]
assert '恢复完成' in dialog.status_label.text()
press(qtbot, dialog.close_button)
assert not dialog.isVisible()
def test_recovery_cancel_queue_never_calls_native_restore(controls, qtbot):
from cbb_refresh_verify.operation_queue import NativeQueue
from cbb_refresh_verify.ui.backup_recovery_dialog import BackupRecoveryDialog
calls = []
queue = NativeQueue()
queue.active = True
dialog = BackupRecoveryDialog(['Beta'],
lambda name: VerifyRequest(controls.library, name, controls.library.parent/'evidence'),
recoverer=lambda *a, **k: calls.append(a))
dialog.native_queue = queue
qtbot.addWidget(dialog)
dialog.show()
dialog.source_edit.setText(str(controls.source))
with modal_click(qtbot, QMessageBox.Yes):
press(qtbot, dialog.restore_button)
qtbot.waitUntil(dialog.cancel_queue_button.isEnabled)
press(qtbot, dialog.cancel_queue_button)
qtbot.waitUntil(lambda: not dialog.busy)
assert calls == [] and dialog.stop.is_set()
press(qtbot, dialog.close_button)
@pytest.mark.parametrize('attribute, expected', [('manual_button','last_user_saved'),
('auto_button','autosave'), ('cancel_button','cancel')])
def test_version_choice_buttons_choose_only_the_clicked_version(qtbot, attribute, expected):
from cbb_refresh_verify.pcb_restore_prompt import RestoreChoice
from cbb_refresh_verify.ui.pcb_restore_dialog import PcbRestoreDialog
choice = RestoreChoice('Beta', 'fixture.lmc', [dict(kind=kind, enabled=True, date='2026/11/11 10:00')
for kind in ('last_user_saved','autosave')])
dialog = PcbRestoreDialog(choice)
qtbot.addWidget(dialog)
dialog.show()
press(qtbot, getattr(dialog, attribute))
assert choice.decision == expected
dialog.close()
assert choice.decision == expected
@pytest.fixture
def residual(controls, qtbot, monkeypatch):
from cbb_refresh_verify import library_lock, residual_sessions
from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog
row = dict(project='Beta', name='ExpeditionPCB.exe', pid=10, detail='fixture session',
scope_confirmed=True, owner_sid='S-1-fixture', session_id=1, force_user_confirmed=True,
image='C:/Fixture/ExpeditionPCB.exe', created_handle='fixture-created',
native_activity=dict(status='IDLE', detail='fixture returned'),
desktops=['CbbFixture'], windows=[dict(title='Fixture native prompt', output='Fixture details')],
prompt=dict(text='Save the changed fixture?'), cancel_prompt=dict(text='Cancel fixture'))
plan = dict(library=str(controls.library), sessions=[row])
state = SimpleNamespace(scans=[], releases=[], cancels=[], saves=[], row=row, plan=plan,
entered=Event(), finish=Event(), hold=False)
def inspect(library):
state.scans.append(library)
return plan
def release(actual, folder, **kwargs):
state.releases.append(kwargs)
if state.hold:
state.entered.set()
assert state.finish.wait(5)
return dict(status='PARTIAL', sessions=[dict(row, release_status='WAITING', consent_allowed=True)])
def cancel(actual, library, folder, **kwargs):
state.cancels.append(actual)
return dict(status='PARTIAL', detail='Fixture cancel received',
sessions=[dict(row, release_status='WAITING')])
monkeypatch.setattr(library_lock, 'inspect_residual_sessions', inspect)
monkeypatch.setattr(library_lock, 'release_residual_sessions', release)
monkeypatch.setattr(residual_sessions, 'request_native_cancel', cancel)
monkeypatch.setattr(residual_sessions, 'answer_save_question',
lambda actual, code: state.saves.append((actual['pid'], code)))
dialog = ResidualReleaseDialog(controls.library, controls.library.parent/'release-evidence')
qtbot.addWidget(dialog)
dialog.show()
qtbot.waitUntil(lambda: not dialog.busy)
state.dialog = dialog
yield state
state.finish.set()
qtbot.waitUntil(lambda: not dialog.busy)
def test_residual_refresh_details_confirm_and_close(residual, qtbot):
d = residual.dialog
press(qtbot, d.refresh_button)
qtbot.waitUntil(lambda: not d.busy)
assert len(residual.scans) == 2 and d.table.rowCount() == 1
press(qtbot, d.details_button)
details = d.native_details
assert 'Fixture native prompt' in details.detailedText()
expand = next(b for b in details.findChildren(QPushButton) if 'Details' in b.text())
press(qtbot, expand)
assert details.findChild(QTextEdit).isVisible()
press(qtbot, details.button(QMessageBox.Close))
press(qtbot, d.confirm_button)
qtbot.waitUntil(lambda: not d.busy)
assert len(residual.releases) == 1 and residual.releases[0]['force'] is False
assert d.table.item(0, 6).text() == '允许'
assert d.table.item(0, 7).text() == '未释放'
press(qtbot, d.close_button)
assert not d.isVisible()
@pytest.mark.parametrize('answer, code', [(QMessageBox.Yes,6),(QMessageBox.No,7),(QMessageBox.Cancel,2)])
def test_residual_save_prompt_buttons_preserve_the_users_choice(residual, qtbot, answer, code):
d = residual.dialog
with modal_click(qtbot, answer):
press(qtbot, d.prompt_button)
qtbot.waitUntil(lambda: not d.busy)
assert residual.saves == [(10, code)]
assert d.isVisible() and residual.releases == []
@pytest.mark.parametrize('answer', [QMessageBox.No,QMessageBox.Yes])
def test_residual_native_cancel_confirm_and_decline(residual, qtbot, answer):
d = residual.dialog
with modal_click(qtbot, answer):
press(qtbot, d.cancel_native_button)
qtbot.waitUntil(lambda: not d.busy)
assert len(residual.cancels) == (1 if answer == QMessageBox.Yes else 0)
assert residual.releases == []
@pytest.mark.parametrize('answer', [QMessageBox.Cancel,QMessageBox.Yes])
def test_residual_force_buttons_require_actual_confirmation(residual, qtbot, answer):
d = residual.dialog
with modal_click(qtbot, answer):
press(qtbot, d.force_button)
qtbot.waitUntil(lambda: not d.busy)
assert [call['force'] for call in residual.releases] == ([True] if answer == QMessageBox.Yes else [])
def test_residual_busy_repeated_clicks_and_stop_release(residual, qtbot):
d = residual.dialog
residual.hold = True
try:
press(qtbot, d.confirm_button)
qtbot.waitUntil(residual.entered.is_set)
for _ in range(5):
qtbot.mouseClick(d.confirm_button, Qt.LeftButton)
qtbot.mouseClick(d.refresh_button, Qt.LeftButton)
assert len(residual.releases) == 1 and len(residual.scans) == 1
press(qtbot, d.close_button)
assert d.stop.is_set() and d.isVisible()
finally:
residual.finish.set()
qtbot.waitUntil(lambda: not d.busy)
press(qtbot, d.close_button)
def test_result_release_and_resume_buttons_run_only_unexecuted_items(controls, qtbot, monkeypatch):
from cbb_refresh_verify import library_lock
w = controls.window
controls.result = VerifyResult('FAIL', safe_to_continue=False, stderr='Fixture release unconfirmed')
with modal_click(qtbot, QMessageBox.Yes):
press(qtbot, w.batch_button)
qtbot.waitUntil(lambda: not w.busy)
assert [request.block_name for request in controls.runs] == ['Beta']
assert not w._resume_batch_action.isEnabled()
proof = dict(status='RELEASE_CONFIRMED', library=str(controls.library), evidence_path='fixture-proof.json')
monkeypatch.setattr(library_lock, 'release_residual_sessions',
lambda *a, **k: dict(status='RELEASE_CONFIRMED', proof=proof, sessions=[]))
press(qtbot, w._residual_release_action)
qtbot.waitUntil(lambda: not w.release_dialog.busy)
press(qtbot, w.release_dialog.confirm_button)
qtbot.waitUntil(lambda: not w.release_dialog.busy)
press(qtbot, w.release_dialog.close_button)
qtbot.waitUntil(lambda: not w.busy)
controls.result = VerifyResult('PASS')
press(qtbot, w._resume_batch_action)
qtbot.waitUntil(lambda: not w.busy)
assert [request.block_name for request in controls.runs] == ['Beta','Gamma']
@pytest.mark.parametrize('entry', ['icdb_copy', 'icdb_release', 'batch_copy', 'batch_close'])
def test_result_recovery_and_release_entries_stay_bound_to_failed_cbb(controls, qtbot, entry):
from dataclasses import replace
from test_reimport_recovery import failed_repair
w = controls.window
if entry.startswith('icdb'):
tab(qtbot, w, 1)
w.search_edit.setText('Beta')
controls.result = failed_repair(controls.library.parent/'failure.json', safe=entry=='icdb_copy')
with modal_click(qtbot, QMessageBox.Yes):
press(qtbot, w.icdb_repair_button)
qtbot.waitUntil(lambda: not w._icdb_active())
label = '查看残留并释放…' if entry=='icdb_release' else '选择副本恢复…'
press(qtbot, next(b for b in w.icdb_summary.buttons() if b.text()==label))
else:
# This is the supported legacy maintenance-result shape; current UI
# maintenance uses the independent IcdbCheckTask route above.
req = replace(w._request('Beta'), maintenance=True)
w._batch_requests = (req,)
w._batch_records = {'Beta':w._records_by_name['Beta']}
w._batch_done(([failed_repair(controls.library.parent/'failure.json',safe=True)], None))
w._update()
if entry=='batch_close':
summary = w.summary
press(qtbot, summary.button(QMessageBox.Close))
assert not isValid(summary) or not summary.isVisible()
return
press(qtbot, w._reimport_summary_action)
if entry=='icdb_release':
qtbot.waitUntil(lambda: not w.release_dialog.busy)
assert w.release_dialog.library == controls.library
press(qtbot, w.release_dialog.close_button)
else:
dialog = w.management_dialog
assert [req.name for req in dialog.requests()] == ['Beta']
assert Path(dialog.recovery_from['Beta']) == controls.library.parent/'failure.json'
press(qtbot, dialog.close_button)
qtbot.waitUntil(lambda: not w.busy)
if entry=='icdb_copy':
tab(qtbot,w,1)
press(qtbot,w.reimport_button)
assert [req.name for req in w.management_dialog.requests()] == ['Beta']
press(qtbot,w.management_dialog.close_button)
def test_invalidated_catalog_buttons_ignore_clicks(controls, qtbot):
w = controls.window
w.lmc_edit.setText('not-loaded.lmc')
for index, attributes in [(0,['selected_batch_button','batch_button']),
(1,['icdb_repair_button','native_backup_button','backup_restore_button']),
(2,['add_button','update_button','remove_button'])]:
tab(qtbot,w,index)
for attribute in attributes:
button = getattr(w,attribute)
assert not button.isEnabled()
qtbot.mouseClick(button,Qt.LeftButton)
assert controls.runs == [] and controls.native == []
assert getattr(w,'management_dialog',None) is None
@pytest.mark.parametrize('attribute, failure', [('logs_button','shell'),
('logs_button','directory'),('recovery_button','shell')])
def test_log_and_evidence_buttons_report_external_failure(controls,qtbot,monkeypatch,attribute,failure):
import cbb_refresh_verify.ui.main_window as ui
def fail(path):
raise OSError('Fixture shell access denied')
w = controls.window
if failure=='shell':
monkeypatch.setattr(ui.os,'startfile',fail)
expected = 'Fixture shell access denied'
else:
w.data_root = controls.source/'logs'
expected = 'Beta.prj'
if attribute=='recovery_button':
w.recovery_path = controls.library.parent
w.recovery_button.setEnabled(True)
press(qtbot,getattr(w,attribute))
assert expected in w.status_label.text()
assert controls.opened == []