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

436 lines
23 KiB
Python

import json
import pytest
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
@pytest.mark.parametrize('missing', [False, True])
def test_terminal_history_sums_persisted_counts_and_preserves_unknown(ui, monkeypatch, qtbot, missing):
from dx_productivity.dsh.task_lifecycle import preflight
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
ids = [task.task_id for task in ui.tasks]
ctl.runs.begin('e' * 32, ids, preflight(ui.service, ids)['plan_hashes'])
tasks = [{'task_id': ids[0], 'saved_items': 2, 'failed_items': 0, 'no_match_items': 1},
{'task_id': ids[1], 'saved_items': None if missing else 3, 'failed_items': 1, 'no_match_items': 0}]
ctl.runs.finish('e' * 32, {'status': 'failed', 'tasks': tasks})
ctl.refresh()
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
row = view.operations['runs'][0]
assert row['counters'] == {'saved_items': None if missing else 5, 'failed_items': 1, 'no_match_items': 1}
assert row['tasks'] == tasks
def test_orphan_schedule_reconciliation_waits_for_native_confirmation(ui, monkeypatch, qtbot):
from dx_productivity.dsh.task_lifecycle import preflight
from PySide6.QtWidgets import QDialogButtonBox
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
ids = [ui.tasks[0].task_id]
row = ctl.schedules.save({'task_ids': ids, 'not_before': '2026-10-30T12:00:00Z'}, preflight(ui.service, ids)['plan_hashes'])
ctl.schedules.claim(row['schedule_id'], run_id='9' * 32)
for key, accept in [('1', False), ('2', True)]:
ctl.request({'request_id': key * 32, 'spec': {'operation': 'reconcile_schedule', 'schedule_id': row['schedule_id']}})
qtbot.waitUntil(lambda: ctl.dialog is not None, timeout=5000)
assert ctl.schedules.get(row['schedule_id'])['status'] == 'claimed'
button = QDialogButtonBox.StandardButton.Ok if accept else QDialogButtonBox.StandardButton.Cancel
qtbot.mouseClick(ctl.dialog.buttons.button(button), Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: len(view.lifecycle_results) == int(key), timeout=5000)
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
assert ctl.schedules.get(row['schedule_id'])['status'] == ('interrupted' if accept else 'claimed')
assert view.lifecycle_results[-1]['status'] == 'schedule_reconciled'
assert view.operations['schedule_events'][0]['payload']['reconciled'] is True
assert not ui.calls
def test_missing_schedule_archive_degrades_its_section_without_hiding_history(ui, monkeypatch, qtbot):
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
with ctl.schedules._connect() as db:
for _ in range(4):
ctl.schedules._event(db, 'a' * 32, '2026-10-31T12:00:00Z', 'result', None, {'status': 'completed'})
ctl.schedules.archive_events(keep=2)
next((ui.data / 'dsh/schedule-audit').glob('*.jsonl')).unlink()
ctl.refresh()
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
assert view.operations['schedule_audit']['status'] == 'unavailable'
assert view.operations['section_errors'] == [{'section': 'schedule_audit', 'code': 'section_unavailable'}]
assert view.operations['health']['status'] == 'degraded'
assert len(view.operations['schedule_events']) == 2
assert isinstance(view.operations['runs'], list)
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_execution_health_follows_real_window_run_state(ui, monkeypatch, qtbot):
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
ctl.refresh()
qtbot.waitUntil(lambda: ctl.worker is None)
ui.window._begin_run(ui.tasks[0].task_id)
ui.window._bind_dsh_context()
check = next(row for row in view.operations['health']['checks'] if row['name'] == 'execution')
assert check['code'] == 'execution_running'
ui.window._finish_run()
check = next(row for row in view.operations['health']['checks'] if row['name'] == 'execution')
assert check['code'] == 'idle'
def test_receipt_enrichment_failure_does_not_erase_executor_result(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
original = RunJournal.finish
calls = []
def fail_enrichment(self, run_id, receipt):
calls.append(run_id)
if len(calls) > 1:
raise OSError('controlled enrichment persistence failure')
return original(self, run_id, receipt)
monkeypatch.setattr(RunJournal, 'finish', fail_enrichment)
ids = [ui.tasks[0].task_id]
receipt = execute_confirmed_run(ui.service, ui.data, ids, api.preflight(ui.service, ids), Event(), 'f' * 32)
assert receipt['status'] == 'completed'
assert receipt['reporting_errors'][0]['code'] == 'receipt_enrichment_unavailable'
assert RunJournal(ui.data).get('f' * 32)['result']['entries'][0]['state'] == 'completed'
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 corrupt_decision_log(controller, damage):
row = controller.decisions.append({'incident_id': 'a' * 24, 'trigger': 'worker_error',
'gates': {}, 'candidate_action': 'none', 'authorized_scope': {}, 'outcome': 'pending_issue'})
with controller.decisions.path.open('a', encoding='utf8') as stream:
stream.write(json.dumps(row) + '\n' if damage == 'duplicate' else '{"sequence":')
return controller.decisions.path.read_bytes()
@pytest.mark.parametrize('operation', ['refresh', 'history', 'health', 'decisions', 'tickets'])
@pytest.mark.parametrize('damage', ['duplicate', 'partial'])
def test_corrupt_audit_is_isolated_from_aggregate_reads(ui, monkeypatch, qtbot, operation, damage):
from dx_productivity.dsh import task_lifecycle as api
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
ids = [ui.tasks[0].task_id]
report = api.preflight(ui.service, ids)
ctl.runs.begin('a' * 32, ids, report['plan_hashes'])
incident = ui.data / 'dsh' / 'incidents' / ('b' * 24)
incident.mkdir(parents=True)
(incident / 'incident.json').write_text(json.dumps({'incident_id': 'b' * 24,
'ticket': {'number': 8, 'url': 'https://git.simgreek.com/Skyworth_Digital_Hardware/dxdesigner-part-replacement/issues/8'}}), encoding='utf8')
before = corrupt_decision_log(ctl, damage)
# A failed refresh must clear previously displayed decision rows only.
ctl.cache['decisions'] = [{'sequence': 99, 'incident_id': 'c' * 24}]
ctl.request({'request_id': 'b' * 32, 'spec': {'operation': operation}})
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
result = view.lifecycle_results[-1]
assert result['status'] == 'read'
assert result['runs'][0]['run_id'] == 'a' * 32
assert result['tickets'][0]['number'] == 8
assert result['health']['checks']
assert result['decisions'] == []
assert result['decision_audit']['status'] == 'corrupt'
assert result['decision_audit']['code'] == 'audit_log_corrupt'
assert result['decision_audit']['checked'] == 1
assert any(row['name'] == 'decision_audit' and row['status'] == 'degraded' for row in result['health']['checks'])
assert view.operations['activity']['status'] == 'read'
assert view.operations['decision_audit']['status'] == 'corrupt'
assert ctl.decisions.path.read_bytes() == before
assert ctl.decisions.verify()['valid'] is False
with pytest.raises(ValueError, match='decision_log_corrupt'):
ctl.decisions.append({'incident_id': 'd' * 24})
assert not ui.calls
def test_tick_retains_authorized_schedule_dispatch_when_audit_is_corrupt(ui, monkeypatch, qtbot):
from datetime import datetime, timedelta, timezone
from dx_productivity.dsh import task_lifecycle as api
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
ids = [ui.tasks[0].task_id]
report = api.preflight(ui.service, ids)
schedule = ctl.schedules.save({'task_ids': ids, 'not_before': (datetime.now(timezone.utc) - timedelta(minutes=1)).isoformat(),
'auto_start': True}, report['plan_hashes'])
before = corrupt_decision_log(ctl, 'duplicate')
dispatched = []
monkeypatch.setattr(ctl, '_dispatch', lambda row, **options: dispatched.append((row, options)))
ctl.tick()
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
qtbot.waitUntil(lambda: bool(dispatched), timeout=5000)
assert view.operations['decision_audit']['status'] == 'corrupt'
assert view.operations['health']['checks']
assert ctl.cache['schedules'][0]['ready'] is True
assert dispatched[0][0]['schedule_id'] == schedule['schedule_id']
assert dispatched[0][1]['automatic'] is True
assert ctl.decisions.path.read_bytes() == before
assert not ui.calls
def test_audit_read_error_does_not_hide_health_or_leak_error_text(ui, monkeypatch, qtbot):
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
def unavailable(*_args):
raise OSError('Authorization: Bearer private-test-value')
monkeypatch.setattr(ctl.decisions, 'list', unavailable)
ctl.refresh()
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
assert view.operations['decision_audit']['status'] == 'unavailable'
assert view.operations['health']['checks']
assert 'private-test-value' not in json.dumps(view.operations)
@pytest.mark.parametrize('section', ['experiences', 'schedule_events', 'schedule_audit'])
def test_independent_section_failure_keeps_schedules_and_health_visible(ui, monkeypatch, qtbot, section):
view = setup_view(ui, monkeypatch)
ctl = ui.window._dsh_operations
def unavailable(*_args, **_kwargs):
raise OSError('Authorization: Bearer private-test-value')
target, method = (ctl.experiences, 'refresh') if section == 'experiences' else (
ctl.schedules, 'events' if section == 'schedule_events' else 'audit_status')
monkeypatch.setattr(target, method, unavailable)
ctl.refresh()
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
assert view.operations['section_errors'] == [{'section': section, 'code': 'section_unavailable'}]
assert view.operations['health']['status'] == 'degraded'
assert isinstance(view.operations['schedules'], list)
assert 'private-test-value' not in json.dumps(view.operations)
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
events = ctl.schedules.events()
assert [row['event'] for row in events] == ['result', 'dispatch']
assert events[1]['payload']['automatic'] is True
assert events[0]['payload']['receipt']['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()