107 lines
4.4 KiB
Python
107 lines
4.4 KiB
Python
from pathlib import Path
|
|
from threading import Event
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from dx_productivity.trial_task_center.errors import TaskCenterError
|
|
from dx_productivity.trial_task_center.task_queue import execute_task_queue
|
|
|
|
|
|
class Service:
|
|
def __init__(self, root, outcomes=None):
|
|
self._logging = SimpleNamespace(root=root)
|
|
self.calls = []
|
|
self.outcomes = outcomes or {}
|
|
self.current = None
|
|
self._batch_feedback = None
|
|
|
|
def for_project_task(self, task_id):
|
|
parent = self
|
|
|
|
class Child:
|
|
def get_task(self, task_id):
|
|
return SimpleNamespace(primary_project_id=task_id, copy_part_number_to_value=False)
|
|
|
|
def projects(self, task_id):
|
|
return (SimpleNamespace(path=Path('C:/') / task_id / 'board.prj', selected=True, available=True),)
|
|
|
|
def rules(self, task_id):
|
|
return (SimpleNamespace(old_part_number='OLD', new_part_number='NEW', enabled=True),)
|
|
|
|
def target_plan(self, task_id):
|
|
return ()
|
|
|
|
def has_interrupted_quick_run(self, task_id):
|
|
return False
|
|
|
|
def quick_run_progress(self, task_id):
|
|
return SimpleNamespace(queue_complete=False, next_project_path=self.projects(task_id)[0].path,
|
|
next_old_part_number='OLD', next_new_part_number='NEW')
|
|
|
|
def execute_quick_run_queue(self, task_id, *, expected_item, stop_event):
|
|
parent.calls.append(('start', task_id))
|
|
outcome = parent.outcomes.get(task_id)
|
|
if isinstance(outcome, Exception):
|
|
raise outcome
|
|
if callable(outcome):
|
|
outcome(stop_event)
|
|
parent.calls.append(('end', task_id))
|
|
return SimpleNamespace(paused=stop_event.is_set(),
|
|
progress=SimpleNamespace(failed_items=int(outcome == 'failed'), queue_complete=True),
|
|
last_result=SimpleNamespace(state='saved_ok'))
|
|
|
|
return Child()
|
|
|
|
|
|
def test_tasks_execute_in_confirmed_order_and_finished_queue_does_not_repeat(tmp_path):
|
|
service = Service(tmp_path)
|
|
result = execute_task_queue(service, ('B', 'A'), stop_event=Event())
|
|
assert service.calls == [('start', 'B'), ('end', 'B'), ('start', 'A'), ('end', 'A')]
|
|
assert [entry.state for entry in result.entries] == ['completed', 'completed']
|
|
execute_task_queue(service, ('B', 'A'), stop_event=Event(), queue_id=result.queue_id)
|
|
assert len(service.calls) == 4
|
|
|
|
|
|
def test_changed_confirmed_plan_is_rejected_before_any_executor(tmp_path):
|
|
service = Service(tmp_path)
|
|
with pytest.raises(TaskCenterError, match='assistant_stale'):
|
|
execute_task_queue(service, ('A',), stop_event=Event(), expected_plan_hashes={'A': 'stale'})
|
|
assert not service.calls
|
|
|
|
|
|
def test_safe_failure_is_reported_and_next_task_runs(tmp_path):
|
|
service = Service(tmp_path, {'A': TaskCenterError('quick_run_preflight', 'target absent')})
|
|
result = execute_task_queue(service, ('A', 'B'), stop_event=Event())
|
|
assert [entry.state for entry in result.entries] == ['failed', 'completed']
|
|
assert service.calls[-1] == ('end', 'B')
|
|
|
|
|
|
def test_uncertain_result_blocks_next_task(tmp_path):
|
|
service = Service(tmp_path, {'A': TaskCenterError('quick_run_uncertain', 'unknown')})
|
|
result = execute_task_queue(service, ('A', 'B'), stop_event=Event())
|
|
assert result.paused
|
|
assert result.entries[0].state == 'blocked'
|
|
assert service.calls == [('start', 'A')]
|
|
|
|
|
|
def test_pause_finishes_current_item_and_does_not_start_next_task(tmp_path):
|
|
service = Service(tmp_path, {'A': lambda stop: stop.set()})
|
|
result = execute_task_queue(service, ('A', 'B'), stop_event=Event())
|
|
assert result.paused
|
|
assert service.calls == [('start', 'A'), ('end', 'A')]
|
|
|
|
|
|
def test_duplicate_tasks_and_projects_rejected_before_dispatch(tmp_path):
|
|
service = Service(tmp_path)
|
|
with pytest.raises(TaskCenterError):
|
|
execute_task_queue(service, ('A', 'A'), stop_event=Event())
|
|
assert service.calls == []
|
|
|
|
|
|
def test_resume_rejects_another_task_order(tmp_path):
|
|
service = Service(tmp_path)
|
|
result = execute_task_queue(service, ('A', 'B'), stop_event=Event())
|
|
with pytest.raises(TaskCenterError):
|
|
execute_task_queue(service, ('B', 'A'), stop_event=Event(), queue_id=result.queue_id)
|