Files
dxdesigner-part-replacement/tests/ui/test_dsh_task_lifecycle.py
T
阿白叔 eba935e710
Core regression / Python 3.12 core, intervention UI and release configuration (push) Failing after 21s
Core regression / JavaScript syntax (push) Successful in 3s
Core regression / Python 3.12 core, intervention UI and release configuration (pull_request) Failing after 21s
Core regression / JavaScript syntax (pull_request) Successful in 3s
fix(dsh): keep AI waits off task execution and adapt main capabilities
2026-11-05 17:15:29 +08:00

387 lines
18 KiB
Python

import pytest
from PySide6.QtCore import Qt
from PySide6.QtWidgets import QDialogButtonBox
from dx_productivity.trial_task_center.errors import TaskCenterError
def lifecycle():
from dx_productivity.dsh import task_lifecycle
return task_lifecycle
def test_catalog_and_preflight_use_real_tasks_and_do_not_execute(ui):
api = lifecycle()
catalog = api.catalog(ui.service)
assert {t['task_id'] for t in catalog['tasks']} == {t.task_id for t in ui.tasks}
report = api.preflight(ui.service, [ui.tasks[0].task_id])
assert report['ready'] and report['tasks'][0]['enabled_rules'] == 1
assert report['cad_connection_checked'] is False
assert not ui.calls
detail = api.catalog(ui.service, ui.tasks[0].task_id)['detail']
assert detail['rules'][0]['old_part_number'] == 'OLD'
assert detail['rules'][0]['new_part_number'] == 'NEW'
ui.service.delete_task(ui.tasks[0].task_id)
report = api.preflight(ui.service, [ui.tasks[0].task_id])
assert not report['ready'] and report['tasks'][0]['blockers']
def test_confirmed_rule_change_previews_batch_and_commits_once(ui):
api = lifecycle()
spec = {'operation': 'update', 'task_id': ui.tasks[0].task_id,
'patch': {'name': 'Renamed', 'rules': [{'old_part_number': 'OLD', 'new_part_number': 'NEXT'}]}}
plan = api.preview(ui.service, spec)
assert {t['task_id'] for t in plan['affected_tasks']} == {t.task_id for t in ui.tasks}
assert ui.store.list_rules(ui.tasks[0].task_id)[0].new_part_number == 'NEW'
result = api.apply_confirmed(ui.service, 'a' * 32, plan)
assert result['status'] == 'updated'
assert ui.store.get_task(ui.tasks[0].task_id).name == 'Renamed'
for task in ui.tasks:
assert ui.store.list_rules(task.task_id)[0].new_part_number == 'NEXT'
assert api.apply_confirmed(ui.service, 'a' * 32, plan)['replayed']
from dx_productivity.trial_task_center.store import TaskStore
reopened = TaskStore(ui.store.path)
try:
assert reopened.assistant_operation_receipt('a' * 32)['result'] == result
finally:
reopened.close()
assert not ui.calls
def test_preview_includes_derived_cell_reset_and_custom_value_enable(ui):
api = lifecycle()
rule = ui.store.list_rules(ui.tasks[0].task_id)[0]
ui.service.update_rule(rule.rule_id, old_part_number='OLD', new_part_number='NEW', enabled=True, target_cell='QFN')
plan = api.preview(ui.service, {'operation': 'update', 'task_id': ui.tasks[0].task_id,
'patch': {'rules': [{'old_part_number': 'OLD', 'new_part_number': 'NEXT', 'custom_value': 'Explicit value'}]}})
changes = {row['field']: row for row in plan['changes']}
assert changes['OLD.target_cell']['before'] == 'QFN' and changes['OLD.target_cell']['after'] == ''
assert changes['OLD.custom_value_enabled']['after'] is True
api.apply_confirmed(ui.service, '9' * 32, plan)
actual = ui.store.list_rules(ui.tasks[0].task_id)[0]
assert actual.target_cell == '' and actual.custom_value_enabled
def test_stale_preview_rejects_all_changes_and_invalid_patch_is_not_applied(ui):
api = lifecycle()
plan = api.preview(ui.service, {'operation': 'update', 'task_id': ui.tasks[0].task_id,
'patch': {'name': 'Unapplied'}})
ui.service.update_task(ui.tasks[0].task_id, name='Changed elsewhere', note='')
with pytest.raises(TaskCenterError, match='assistant_stale'):
api.apply_confirmed(ui.service, 'b' * 32, plan)
assert ui.store.get_task(ui.tasks[0].task_id).name == 'Changed elsewhere'
with pytest.raises(TaskCenterError):
api.preview(ui.service, {'operation': 'update', 'task_id': ui.tasks[0].task_id,
'patch': {'confirmed': True}})
def test_archive_keeps_evidence_and_preflight_detects_missing_project(ui):
api = lifecycle()
task_id = ui.tasks[0].task_id
plan = api.preview(ui.service, {'operation': 'archive', 'task_id': task_id})
assert api.apply_confirmed(ui.service, 'c' * 32, plan)['status'] == 'archived'
assert ui.store.get_task(task_id).status.value == 'deleted'
assert ui.store.list_rules(task_id)
ui.service.restore_task(task_id)
ui.store.list_projects(task_id)[0].path.unlink()
assert not api.preflight(ui.service, [task_id])['ready']
def controller(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_lifecycle, ui.window._dsh_view
def request(ui, operation, **values):
return {'request_id': 'd' * 32, 'capability': 'manage',
'spec': {'operation': operation, 'task_id': ui.tasks[0].task_id, **values}}
def test_dialog_cancel_and_stale_confirm_do_not_modify(ui, monkeypatch, qtbot):
ctl, view = controller(ui, monkeypatch)
ctl.request(request(ui, 'update', patch={'name': 'Never'}))
qtbot.waitUntil(lambda: ctl.dialog is not None, timeout=5000)
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Cancel), Qt.MouseButton.LeftButton)
assert view.lifecycle_results[-1]['status'] == 'cancelled'
assert ui.service.get_task(ui.tasks[0].task_id).name != 'Never'
ui.settle()
def test_dialog_executes_existing_queue_and_reports_real_no_match(ui, monkeypatch, qtbot):
ctl, view = controller(ui, monkeypatch)
ctl.request({'request_id': 'e' * 32, 'capability': 'execute',
'spec': {'operation': 'start', 'task_ids': [ui.tasks[0].task_id]}})
qtbot.waitUntil(lambda: ctl.dialog is not None, timeout=5000)
assert not ui.calls
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Ok), Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: bool(view.lifecycle_results), timeout=15000)
result = view.lifecycle_results[-1]
assert result['status'] == 'completed' and result['tasks'][0]['no_match_items'] == 1
assert result['tasks'][0]['saved_items'] == 0 and ui.calls
ui.settle()
def test_cancel_during_preview_read_never_opens_later_dialog(ui, monkeypatch, qtbot):
ctl, view = controller(ui, monkeypatch)
value = request(ui, 'update', patch={'name': 'Never'})
ctl.request(value)
ctl.cancel({'request_id': value['request_id']})
ui.settle()
assert ctl.dialog is None
assert view.lifecycle_results[-1]['status'] == 'cancelled'
def test_abort_during_confirmed_commit_retains_actual_mutation_receipt(ui, monkeypatch, qtbot):
from threading import Event
ctl, view = controller(ui, monkeypatch)
api = lifecycle(); original = api.apply_confirmed
entered, release = Event(), Event()
def delayed(*args):
entered.set()
assert release.wait(5)
return original(*args)
monkeypatch.setattr(api, 'apply_confirmed', delayed)
value = request(ui, 'update', patch={'name': 'Committed truthfully'})
ctl.request(value)
qtbot.waitUntil(lambda: ctl.dialog is not None, timeout=5000)
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Ok), Qt.MouseButton.LeftButton)
try:
qtbot.waitUntil(entered.is_set, timeout=5000)
ctl.cancel({'request_id': value['request_id']})
assert not view.lifecycle_results
finally:
release.set()
qtbot.waitUntil(lambda: bool(view.lifecycle_results), timeout=5000)
assert view.lifecycle_results[-1]['status'] == 'updated'
assert ui.service.get_task(ui.tasks[0].task_id).name == 'Committed truthfully'
assert ui.store.assistant_operation_receipt(value['request_id'])['result']['status'] == 'updated'
ui.settle()
def test_stale_native_preview_rejects_confirmation(ui, monkeypatch, qtbot):
ctl, view = controller(ui, monkeypatch)
ctl.request(request(ui, 'update', patch={'name': 'Never'}))
qtbot.waitUntil(lambda: ctl.dialog is not None and ctl.worker is None, timeout=5000)
ui.service.update_task(ui.tasks[0].task_id, name='External edit', note='')
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Ok), Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: bool(view.lifecycle_results), timeout=5000)
assert view.lifecycle_results[-1]['code'] == 'assistant_stale'
assert ui.service.get_task(ui.tasks[0].task_id).name == 'External edit'
ui.settle()
def test_copy_opens_native_new_scope_dialog_and_returns_actual_ids(ui, monkeypatch, qtbot, tmp_path):
ctl, view = controller(ui, monkeypatch)
ui.service.update_rule(ui.store.list_rules(ui.tasks[0].task_id)[0].rule_id,
old_part_number='OLD', new_part_number='NEW', enabled=False)
root = tmp_path / 'new-scope'; root.mkdir()
project = root / 'new.prj'
project.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
ctl.request(request(ui, 'copy'))
creation = ui.window._dsh_task_creation
qtbot.waitUntil(lambda: creation.dialog is not None, timeout=5000)
dialog = creation.dialog
assert not dialog.spec['rules'][0]['enabled']
qtbot.keyClicks(dialog.directory, str(root))
qtbot.mouseClick(dialog.scan, Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: dialog._worker is None and dialog.projects.count() == 1, timeout=5000)
qtbot.mouseClick(dialog.buttons.button(QDialogButtonBox.StandardButton.Ok), Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: bool(view.lifecycle_results), timeout=5000)
result = view.lifecycle_results[-1]
assert result['created_count'] == 1
assert not ui.store.list_rules(result['task_ids'][0])[0].enabled
assert result['task_ids'][0] not in {t.task_id for t in ui.tasks}
assert not ui.calls
ui.settle()
def test_pause_uses_active_stop_control_and_refuses_other_scope(ui, monkeypatch):
from dx_productivity.trial_task_center.stop_control import StopControl
ctl, view = controller(ui, monkeypatch)
owner = ui.tasks[0].task_id
ui.window._active_quick_run_task_id = owner
ui.window._batch_stop = StopControl()
ctl.request({'request_id': '1' * 32, 'capability': 'execute',
'spec': {'operation': 'pause', 'task_ids': [ui.tasks[1].task_id]}})
assert not ui.window._batch_stop.is_set()
assert view.lifecycle_results[-1]['status'] == 'rejected'
ctl.request({'request_id': '2' * 32, 'capability': 'execute',
'spec': {'operation': 'pause', 'task_ids': [owner]}})
assert ui.window._batch_stop.is_set() and not ui.window._batch_stop.force_event.is_set()
assert view.lifecycle_results[-1]['status'] == 'pause_requested'
ui.window._finish_run()
def test_bom_handoff_requires_native_confirmation_and_never_claims_import(ui, monkeypatch, qtbot):
ctl, view = controller(ui, monkeypatch)
opened = []
monkeypatch.setattr(ui.window.plan_panel, 'import_bom', lambda: opened.append(ui.window.plan_panel.task_id))
ctl.request(request(ui, 'import_bom'))
qtbot.waitUntil(lambda: ctl.dialog is not None or bool(view.lifecycle_results), timeout=5000)
assert ctl.dialog is not None
assert '多选' in ctl.dialog.preview.toPlainText()
assert not opened and not ui.calls
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Ok), Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: bool(view.lifecycle_results), timeout=5000)
assert opened == [ui.tasks[0].task_id]
assert view.lifecycle_results[-1]['status'] == 'handed_off'
assert view.lifecycle_results[-1]['cad_execution_started'] is False
ctl.request(request(ui, 'import_bom'))
assert len(opened) == 1
assert not ui.calls
ui.settle()
def test_bom_handoff_rechecks_selected_task_after_confirmation(ui, monkeypatch, qtbot):
ctl, view = controller(ui, monkeypatch)
opened = []
monkeypatch.setattr(ui.window.plan_panel, 'import_bom', lambda: opened.append(True))
ctl.request(request(ui, 'import_bom'))
qtbot.waitUntil(lambda: ctl.dialog is not None or bool(view.lifecycle_results), timeout=5000)
assert ctl.dialog is not None
ui.open(ui.tasks[1])
qtbot.mouseClick(ctl.dialog.buttons.button(QDialogButtonBox.StandardButton.Ok), Qt.MouseButton.LeftButton)
qtbot.waitUntil(lambda: bool(view.lifecycle_results), timeout=5000)
assert view.lifecycle_results[-1]['status'] == 'rejected'
assert not opened
ui.settle()
@pytest.mark.parametrize('capability', ['catalog', 'preflight', 'manage'])
def test_lifecycle_reads_do_not_reserve_ordinary_task_lane(ui, monkeypatch, qtbot, capability):
from threading import Event
ctl, view = controller(ui, monkeypatch)
ui.settle()
entered, release = Event(), Event()
api = lifecycle()
function = {'catalog': 'catalog', 'preflight': 'preflight', 'manage': 'preview'}[capability]
original = getattr(api, function)
def slow(*args, **kwargs):
entered.set()
assert release.wait(5)
return original(*args, **kwargs)
monkeypatch.setattr(api, function, slow)
spec = ({'task_id': ui.tasks[0].task_id} if capability == 'catalog' else
{'task_ids': [ui.tasks[0].task_id]} if capability == 'preflight' else
{'operation': 'update', 'task_id': ui.tasks[0].task_id, 'patch': {'name': 'Preview'}})
ctl.request({'request_id': 'f' * 32, 'capability': capability, 'spec': spec})
try:
qtbot.waitUntil(entered.is_set, timeout=5000)
lane_reserved = bool(ui.window._workers)
ordinary_execution_enabled = ui.window.run_panel.quick_run_button.isEnabled()
finally:
release.set()
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
if ctl.dialog is not None:
ctl.dialog.reject()
ui.settle()
assert not lane_reserved
assert ordinary_execution_enabled
def test_select_does_not_claim_success_if_ordinary_mutation_starts_during_read(ui, monkeypatch, qtbot):
from threading import Event
ctl, view = controller(ui, monkeypatch)
ui.settle()
entered, release = Event(), Event()
api = lifecycle()
original = api.preview
def slow(*args):
entered.set()
assert release.wait(5)
return original(*args)
monkeypatch.setattr(api, 'preview', slow)
ctl.request({'request_id': '3' * 32, 'capability': 'manage',
'spec': {'operation': 'select', 'task_id': ui.tasks[1].task_id}})
busy = object()
try:
qtbot.waitUntil(entered.is_set, timeout=5000)
ui.window._workers.add(busy)
release.set()
qtbot.waitUntil(lambda: bool(view.lifecycle_results), timeout=5000)
result = view.lifecycle_results[-1]
selected = ui.window._task_id
finally:
release.set()
ui.window._workers.discard(busy)
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
ui.settle()
assert result['status'] == 'busy'
assert selected == ui.tasks[0].task_id
@pytest.mark.parametrize('operation', ['update', 'archive', 'copy', 'execute'])
@pytest.mark.parametrize('busy_kind', ['worker', 'run', 'loading'])
def test_delayed_preview_does_not_open_modal_after_manual_activity(ui, monkeypatch, qtbot, operation, busy_kind):
from threading import Event
from dx_productivity.trial_task_center.stop_control import StopControl
from dx_productivity.trial_task_center.ui.operation_state import ContextReadPhase
ctl, view = controller(ui, monkeypatch)
ui.settle()
entered, release = Event(), Event()
api = lifecycle()
function = 'preflight' if operation == 'execute' else 'preview'
original = getattr(api, function)
def slow(*args, **kwargs):
value = original(*args, **kwargs)
entered.set()
assert release.wait(5)
return value
monkeypatch.setattr(api, function, slow)
value = ({'request_id': '4' * 32, 'capability': 'execute',
'spec': {'operation': 'start', 'task_ids': [ui.tasks[0].task_id]}} if operation == 'execute' else
request(ui, operation, **({'patch': {'name': 'Uncommitted'}} if operation == 'update' else {})))
ctl.request(value)
busy = object()
previous_phase = ui.window._context_phase
try:
qtbot.waitUntil(entered.is_set, timeout=5000)
if busy_kind == 'worker':
ui.window._workers.add(busy)
elif busy_kind == 'run':
ui.window._batch_stop = StopControl()
else:
ui.window._context_phase = ContextReadPhase.LOADING
release.set()
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
qtbot.waitUntil(lambda: ctl.dialog is not None or ui.window._dsh_task_creation.dialog is not None
or bool(view.lifecycle_results), timeout=5000)
modal_opened = ctl.dialog is not None or ui.window._dsh_task_creation.dialog is not None
result = view.lifecycle_results[-1] if view.lifecycle_results else {}
finally:
release.set()
ui.window._workers.discard(busy)
ui.window._batch_stop = None
ui.window._context_phase = previous_phase
if ctl.dialog is not None:
ctl.dialog.reject()
if ui.window._dsh_task_creation.dialog is not None:
ui.window._dsh_task_creation.dialog.reject()
ui.settle()
assert not modal_opened
assert result['status'] == 'busy'
assert not ui.calls
def test_cancelled_read_failure_does_not_replace_cancellation(ui, monkeypatch, qtbot):
from threading import Event
ctl, view = controller(ui, monkeypatch)
entered, release = Event(), Event()
def slow(*args):
entered.set()
assert release.wait(5)
raise TaskCenterError('controlled_read_failure', 'Read failed after cancellation')
monkeypatch.setattr(lifecycle(), 'catalog', slow)
value = {'request_id': '5' * 32, 'capability': 'catalog', 'spec': {}}
ctl.request(value)
try:
qtbot.waitUntil(entered.is_set, timeout=5000)
ctl.cancel(value)
finally:
release.set()
qtbot.waitUntil(lambda: ctl.worker is None, timeout=5000)
ui.settle()
assert [result['status'] for result in view.lifecycle_results] == ['cancelled']