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
387 lines
18 KiB
Python
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']
|