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']