Files
dxdesigner-part-replacement/tests/ui/test_dsh_operations.py
T

240 lines
13 KiB
Python

from PySide6.QtCore import Qt
def setup_view(ui, monkeypatch):
from test_dsh_native_menu import HarnessView
monkeypatch.setattr(type(ui.window), '_create_dsh_view', lambda self: HarnessView(self))
ui.window._open_dsh()
return ui.window._dsh_view
def test_live_snapshot_reports_running_and_pause_request_without_claiming_paused(ui, monkeypatch):
view = setup_view(ui, monkeypatch)
window = ui.window
window._begin_run(ui.tasks[0].task_id)
window._bind_dsh_context()
assert view.binds[-1].status == 'running'
window._pause_queue()
window._bind_dsh_context()
assert view.binds[-1].status == 'running'
assert view.operations['live_run']['pause_requested']
window._finish_run()
assert not view.operations['live_run']['active']
def test_live_owner_and_saved_counts_do_not_follow_selected_task(ui, monkeypatch, qtbot):
from dx_productivity.dsh.live_state import read_live_run
from dx_productivity.trial_task_center.execution_feedback import ExecutionFeedback
feedback = ExecutionFeedback(ui.tasks[0].task_id, stage='save_and_close', stage_seconds=3)
value = read_live_run(ui.service, feedback, elapsed=10, pause_requested=True,
run_id='a' * 32, task_ids=[ui.tasks[0].task_id])
assert value['task_id'] == ui.tasks[0].task_id and value['name'] == ui.tasks[0].name
assert value['stage'] == 'save_and_close' and value['elapsed_seconds'] == 10
assert value['saved_items'] == 0 and value['active'] and value['pause_requested']
assert value['component_count_known'] is False
def test_last_execution_receipt_survives_later_catalog_reads(ui, monkeypatch, qtbot):
view = setup_view(ui, monkeypatch)
controller = ui.window._dsh_lifecycle
controller.request_id = 'b' * 32
controller._respond('b' * 32, status='completed', queue_id='c' * 32,
tasks=[{'task_id': ui.tasks[0].task_id, 'saved_items': 0, 'failed_items': 0, 'no_match_items': 2}])
controller.request({'request_id': 'd' * 32, 'capability': 'catalog', 'spec': {}})
qtbot.waitUntil(lambda: controller.worker is None)
assert view.operations['last_execution']['queue_id'] == 'c' * 32
assert view.operations['last_execution']['tasks'][0]['no_match_items'] == 2
def test_history_read_busy_state_is_published_and_rejection_is_visible(ui, monkeypatch, qtbot):
from threading import Event
view=setup_view(ui,monkeypatch); operations=ui.window._dsh_operations
started,release=Event(),Event()
def read():
started.set();assert release.wait(5);return {}
operations._work(read,lambda _:None,reserve_lane=False)
try:
qtbot.waitUntil(started.is_set)
ui.window._bind_dsh_context()
assert view.operations['busy'] is True
ui.window._dsh_lifecycle.request({'request_id':'b'*32,'capability':'execute',
'spec':{'operation':'start','task_ids':[ui.tasks[0].task_id]}})
assert view.lifecycle_results[-1]['status']=='busy'
assert view.operations['activity']['message']
assert not ui.calls
finally:
release.set()
qtbot.waitUntil(lambda: operations.worker is None)
assert view.operations['busy'] is False
def test_operations_context_publishes_health_and_decision_timeline(ui, monkeypatch, qtbot):
view = setup_view(ui, monkeypatch)
controller = ui.window._dsh_operations
controller.decisions.append({'incident_id': 'a' * 24, 'trigger': 'worker_error',
'evidence_refs': [], 'gates': {}, 'candidate_action': 'none',
'authorized_scope': {}, 'outcome': 'pending_issue'})
controller.refresh()
qtbot.waitUntil(lambda: controller.worker is None, timeout=5000)
assert 'health' in view.operations and isinstance(view.operations['health']['checks'], list)
assert view.operations['decisions'][0]['incident_id'] == 'a' * 24
def test_stopping_generation_does_not_request_pause_of_confirmed_task(ui, monkeypatch):
view = setup_view(ui, monkeypatch); ctl=ui.window._dsh_lifecycle
task_id=ui.tasks[0].task_id; ui.window._begin_run(task_id)
ctl.request_id='9'*32; ctl.active_ids=(task_id,)
ctl.cancel({'request_id':'9'*32,'reason':'conversation_cancelled'})
assert not ui.window._batch_stop.is_set()
assert ctl.request_id=='9'*32
ctl.active_ids=(); ctl.request_id=None; ui.window._finish_run()
def test_native_batch_can_be_paused_using_published_full_scope(ui, monkeypatch):
view=setup_view(ui,monkeypatch); ctl=ui.window._dsh_lifecycle
ids=[task.task_id for task in ui.tasks]
ui.window._begin_run(ids[0]);ui.window._dsh_live_run['task_ids']=ids
ctl.request({'request_id':'a'*32,'capability':'execute','spec':{'operation':'pause','task_ids':ids}})
assert view.lifecycle_results[-1]['status']=='pause_requested' and ui.window._batch_stop.is_set()
ui.window._finish_run()
def test_scheduled_run_requires_native_confirmation_and_executes_once(ui, monkeypatch, qtbot):
from datetime import datetime, timezone, timedelta
from PySide6.QtWidgets import QDialogButtonBox
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
ctl.request({'request_id': '1' * 32, 'spec': {'operation': 'schedule',
'task_ids': [ui.tasks[0].task_id], 'not_before': (datetime.now(timezone.utc)-timedelta(seconds=1)).isoformat(),
'priority': 'high', 'auto_start': True}})
qtbot.waitUntil(lambda: ctl.dialog is not None, timeout=5000)
assert 'OLD' in ctl.dialog.preview.toPlainText() and 'NEW' in ctl.dialog.preview.toPlainText()
assert '器件数量未知' in ctl.dialog.preview.toPlainText()
assert not ui.calls and not ctl.schedules.list_schedules()
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Ok), Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: ctl.worker is None and bool(ctl.schedules.list_schedules()), timeout=5000)
ctl.tick()
qtbot.waitUntil(lambda: bool(ui.calls), timeout=10000)
qtbot.waitUntil(lambda: ctl.schedules.list_schedules()[0]['status'] == 'completed', timeout=10000)
ctl.tick(); ui.settle()
assert len(ui.calls) == 1
assert view.operations['last_execution']['tasks'][0]['no_match_items'] == 1
def test_ops_impact_and_history_are_read_only_and_native_cancel_does_not_schedule(ui, monkeypatch, qtbot):
from PySide6.QtWidgets import QDialogButtonBox
view = setup_view(ui, monkeypatch); ctl = ui.window._dsh_operations
ctl.request({'request_id': '2' * 32, 'spec': {'operation': 'impact', 'task_ids': [ui.tasks[0].task_id]}})
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
assert view.operations['impact']['component_count'] is None and not ui.calls
ctl.request({'request_id': '3' * 32, 'spec': {'operation': 'schedule_dialog', 'task_ids': [ui.tasks[0].task_id]}})
qtbot.waitUntil(lambda: ctl.dialog is not None, timeout=5000)
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Cancel), Qt.MouseButton.LeftButton)
assert not ctl.schedules.list_schedules() and not ui.calls
def test_confirmed_execution_writes_reserved_checkpoint_and_persistent_run_receipt(ui, monkeypatch, qtbot):
from PySide6.QtWidgets import QDialogButtonBox
view = setup_view(ui, monkeypatch); ctl = ui.window._dsh_lifecycle
ctl.request({'request_id': '4' * 32, 'capability': 'execute',
'spec': {'operation': 'start', 'task_ids': [ui.tasks[0].task_id]}})
qtbot.waitUntil(lambda: ctl.dialog is not None, timeout=5000)
assert '器件数量未知' in ctl.dialog.preview.toPlainText()
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Ok), Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: bool(view.lifecycle_results), timeout=10000)
result = view.lifecycle_results[-1]
assert result['queue_id'] == result['run_id']
from dx_productivity.dsh.run_journal import RunJournal
journal = RunJournal(ui.data)
assert journal.get(result['run_id'])['result']['tasks'][0]['no_match_items'] == 1
assert (ui.data / 'task-queues' / (result['run_id']+'.json')).is_file()
ui.settle()
def test_completed_queue_outcome_survives_unavailable_post_run_context(ui, monkeypatch):
from threading import Event
from dx_productivity.dsh import task_lifecycle as api
from dx_productivity.dsh.execution_runs import execute_confirmed_run
from dx_productivity.dsh.run_journal import RunJournal
ids = [ui.tasks[0].task_id]; report = api.preflight(ui.service, ids)
original = ui.service.task_context
def lost_context(*args, **kwargs):
if ui.calls:
raise OSError('controlled receipt read failure')
return original(*args, **kwargs)
monkeypatch.setattr(ui.service, 'task_context', lost_context)
receipt = execute_confirmed_run(ui.service, ui.data, ids, report, Event(), '5' * 32)
assert receipt['status'] == 'completed' and receipt['entries'][0]['state'] == 'completed'
assert receipt['tasks'][0]['no_match_items'] is None and receipt['reporting_errors']
assert RunJournal(ui.data).get('5' * 32)['result']['entries'][0]['state'] == 'completed'
assert len(ui.calls) == 1
def test_schedule_claim_journal_failure_is_retained_as_interrupted_without_execution(ui, monkeypatch):
import pytest
from datetime import datetime, timezone, timedelta
from threading import Event
from dx_productivity.dsh import task_lifecycle as api
from dx_productivity.dsh.execution_runs import execute_confirmed_run
from dx_productivity.dsh.run_journal import RunJournal
from dx_productivity.dsh.scheduling import ScheduleStore
ids = [ui.tasks[0].task_id]; report = api.preflight(ui.service, ids)
schedules = ScheduleStore(ui.data)
row = schedules.save({'task_ids': ids, 'not_before': (datetime.now(timezone.utc)-timedelta(seconds=1)).isoformat(),
'auto_start': True}, report['plan_hashes'])
def failed_begin(*_args, **_kwargs):
raise OSError('controlled journal failure')
monkeypatch.setattr(RunJournal, 'begin', failed_begin)
with pytest.raises(OSError):
execute_confirmed_run(ui.service, ui.data, ids, report, Event(), '6' * 32, schedule=row)
actual = schedules.get(row['schedule_id'])
assert actual['status'] == 'interrupted' and actual['run_id'] == '6' * 32
assert not ui.calls
def test_saved_target_cell_survives_context_read_and_impact_preview(ui):
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow
from dx_productivity.dsh.impact import execution_impact
task_id = ui.tasks[0].task_id
project = ui.service.projects(task_id)[0]
row = TargetPlanRow(ComponentTarget(project.path, 'MAIN', '1', 'uid-one', 'R1', 'OLD', 'Original'),
enabled=True, new_part_number='NEW', target_cell='QFN')
ui.store.record_target_inventory(task_id, [row.target])
ui.service.replace_target_plan(task_id, [row])
assert ui.service.task_context(task_id).targets[0].target_cell == 'QFN'
report = execution_impact(ui.service, [task_id])
assert report['component_count'] == 1 and report['rows'][0]['target_cell'] == 'QFN'
def test_resume_original_queue_after_controller_restart_skips_completed_step(ui, monkeypatch, qtbot):
from threading import Event
from PySide6.QtWidgets import QDialogButtonBox
from dx_productivity.dsh import task_lifecycle as api
from dx_productivity.dsh.execution_runs import execute_confirmed_run
from dx_productivity.dsh.run_journal import RunJournal
task_id = ui.tasks[0].task_id
ui.service.add_rule(task_id, 'SECOND', 'TARGET')
ids=[task_id]; report=api.preflight(ui.service, ids)
stop=Event()
child = ui.service.for_project_task(task_id)
original = child._quick_run_preparer._process_runner
def pausing(command, timeout):
result = original(command, timeout)
stop.set()
return result
child._quick_run_preparer._process_runner = pausing
first=execute_confirmed_run(ui.service, ui.data, ids, report, stop, '7'*32)
assert first['status']=='paused' and len(ui.calls)==1
child._quick_run_preparer._process_runner = original
view = setup_view(ui, monkeypatch)
ui.window._dsh_lifecycle.request({'request_id':'8'*32,'capability':'execute',
'spec':{'operation':'resume','run_id':'7'*32}})
qtbot.waitUntil(lambda: ui.window._dsh_lifecycle.dialog is not None,timeout=5000)
assert '77777777' in ui.window._dsh_lifecycle.dialog.preview.toPlainText()
qtbot.mouseClick(ui.window._dsh_lifecycle.dialog.buttons.button(QDialogButtonBox.StandardButton.Ok),Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: bool(view.lifecycle_results),timeout=15000)
assert view.lifecycle_results[-1]['run_id']=='7'*32
assert view.lifecycle_results[-1]['status']=='completed' and len(ui.calls)==2
assert RunJournal(ui.data).get('7'*32)['status']=='completed'
ui.settle()