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

215 lines
10 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()