146 lines
7.4 KiB
Python
146 lines
7.4 KiB
Python
"""Actual command, journal and queue behavior at a controlled native boundary."""
|
|
import csv
|
|
import subprocess
|
|
from dataclasses import replace
|
|
from pathlib import Path
|
|
from threading import Event
|
|
|
|
import pytest
|
|
|
|
from dx_productivity.trial_task_center.errors import TaskCenterError
|
|
from dx_productivity.trial_task_center.execution_journal import read_command_rows
|
|
from dx_productivity.trial_task_center.logging_setup import configure_logging
|
|
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer, _decode_vbs_field
|
|
from dx_productivity.trial_task_center.service import TaskCenterService
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow
|
|
from dx_productivity.trial_task_center.task_queue import execute_task_queue
|
|
|
|
|
|
@pytest.fixture
|
|
def component_case(tmp_path):
|
|
calls = []
|
|
outcomes = {}
|
|
def worker(command, timeout):
|
|
root = Path(command[3])
|
|
with (root / 'current-command.tsv').open(encoding='utf-8-sig') as stream:
|
|
row = {key: _decode_vbs_field(value) for key, value in
|
|
next(csv.DictReader(stream, delimiter='\t')).items()}
|
|
selectors = row['target_selectors'].split('\x1e')
|
|
refdes = tuple(selector.split('\x1f')[1] for selector in selectors)
|
|
calls.append((row['task_id'], refdes))
|
|
result = outcomes.get((row['task_id'], refdes), 'saved_ok')
|
|
if isinstance(result, list):
|
|
result = result.pop(0) if len(result) > 1 else result[0]
|
|
if result == 'attach_failed':
|
|
return subprocess.CompletedProcess(command, 2, '', 'controlled attachment failure')
|
|
with (root / 'status.tsv').open('a', encoding='utf-8') as stream:
|
|
if result == 'saved_ok':
|
|
stream.write(f'{command[-1]}\tawaiting_native_replace\t\tcaptured\n')
|
|
stream.write(f'{command[-1]}\t{result}\tbatch_closed\tControlled {result}\n')
|
|
if outcomes.get('after_call'):
|
|
outcomes['after_call'](len(calls))
|
|
return subprocess.CompletedProcess(command, 0, '', '')
|
|
for name in ('A', 'B'):
|
|
project = tmp_path / 'projects' / name / 'board.prj'
|
|
project.parent.mkdir(parents=True)
|
|
project.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
|
|
store = TaskStore(tmp_path / 'tasks.db')
|
|
service = TaskCenterService(store, configure_logging(tmp_path / 'data'),
|
|
quick_run_preparer=QuickRunPreparer(tmp_path / 'data', process_runner=worker,
|
|
cscript_resolver=lambda: Path('controlled-cscript'),
|
|
sheet_discoverer=lambda _: (('MAIN', '1'),)))
|
|
tasks = service.create_project_tasks(tmp_path / 'projects')
|
|
for task in tasks:
|
|
project = service.projects(task.task_id)[0].path
|
|
targets = tuple(ComponentTarget(project, 'MAIN', '1', f'u{i}', f'R{i}', 'OLD', '10K')
|
|
for i in (1, 2))
|
|
store.record_target_inventory(task.task_id, targets)
|
|
store.replace_target_plan(task.task_id, tuple(TargetPlanRow(t, True, 'NEW') for t in targets))
|
|
yield service, store, tasks, calls, outcomes
|
|
store.close()
|
|
|
|
|
|
def test_same_rule_same_value_produces_distinct_single_uid_commands(component_case):
|
|
service, _, tasks, calls, _ = component_case
|
|
result = execute_task_queue(service, (tasks[0].task_id,), stop_event=Event())
|
|
assert not result.paused
|
|
assert [refs for _, refs in calls] == [('R1',), ('R2',)]
|
|
rows = read_command_rows(service.for_project_task(tasks[0].task_id)._quick_run_preparer.data_root /
|
|
'quick-run' / 'command.tsv')
|
|
assert [row['execution_unit'] for row in rows] == ['component', 'component']
|
|
|
|
|
|
def test_safe_component_failure_continues_independent_component_and_project(component_case):
|
|
service, store, tasks, calls, outcomes = component_case
|
|
ids = tuple(t.task_id for t in tasks)
|
|
outcomes[(ids[0], ('R1',))] = 'batch_failed'
|
|
result = execute_task_queue(service, ids, stop_event=Event())
|
|
assert not result.paused
|
|
assert [entry.state for entry in result.entries] == ['failed', 'completed']
|
|
assert calls == [(ids[0], ('R1',)), (ids[0], ('R2',)), (ids[1], ('R1',)), (ids[1], ('R2',))]
|
|
execute_task_queue(service, ids, stop_event=Event(), queue_id=result.queue_id)
|
|
assert len(calls) == 4
|
|
assert store._connection.execute("SELECT count(*) FROM execution_operations WHERE state='verified'").fetchone()[0] == 3
|
|
|
|
|
|
def test_uncertain_component_never_runs_same_project_remainder(component_case):
|
|
service, _, tasks, calls, outcomes = component_case
|
|
task_id = tasks[0].task_id
|
|
outcomes[(task_id, ('R1',))] = 'batch_saved_unverified'
|
|
result = execute_task_queue(service, (task_id,), stop_event=Event())
|
|
assert result.paused
|
|
assert calls == [(task_id, ('R1',))]
|
|
|
|
|
|
def test_problem_retry_budget_survives_rebinding_and_is_shared(component_case):
|
|
service, _, tasks, _, outcomes = component_case
|
|
task_id = tasks[0].task_id
|
|
outcomes[(task_id, ('R1',))] = 'batch_failed'
|
|
execute_task_queue(service, (task_id,), stop_event=Event())
|
|
# Unknown native failures are visible but cannot obtain automatic replay.
|
|
assert service.reserve_problem_retry(task_id, source='dsh') == ()
|
|
issues = service.execution_problems(task_id)
|
|
assert len(issues) == 1 and issues[0]['classification'] == 'manual'
|
|
|
|
|
|
def test_old_group_receipt_cannot_be_split_into_new_work(component_case):
|
|
service, _, tasks, _, _ = component_case
|
|
child = service.for_project_task(tasks[0].task_id)
|
|
task = tasks[0]
|
|
preparer = child._quick_run_preparer
|
|
handoff = preparer.prepare(task.task_id, child.projects(task.task_id), child._execution_rules(task.task_id),
|
|
sheet_targets={str(child.projects(task.task_id)[0].path).casefold(): (('MAIN', '1'),)},
|
|
split_targets=False)
|
|
rows = read_command_rows(handoff.command_path)
|
|
journal = preparer.journal
|
|
journal.bind(task.task_id, rows, {})
|
|
journal.finish(journal.claim(task.task_id, rows[0]), 'saved_ok', 'batch_closed', 'legacy group')
|
|
split = dict(rows[0], target_selectors='u1\x1fR1\x1f10K', execution_unit='component')
|
|
with pytest.raises(TaskCenterError):
|
|
journal.bind(task.task_id, (split,), {})
|
|
|
|
|
|
def test_unresolved_attempt_blocks_another_uid_before_any_failure(component_case):
|
|
service, _, tasks, _, _ = component_case
|
|
child = service.for_project_task(tasks[0].task_id)
|
|
handoff = child._quick_run_preparer.ensure_batch_handoff(tasks[0].task_id,
|
|
child.projects(tasks[0].task_id), child._execution_rules(tasks[0].task_id))
|
|
rows = read_command_rows(handoff.command_path)
|
|
journal = child._quick_run_preparer.journal
|
|
journal.bind(tasks[0].task_id, rows, {})
|
|
journal.claim(tasks[0].task_id, rows[0])
|
|
with pytest.raises(TaskCenterError, match='quick_run_uncertain'):
|
|
journal.claim(tasks[0].task_id, rows[1])
|
|
|
|
|
|
def test_overlapping_component_commands_rejected_before_first_dispatch(component_case):
|
|
service, _, tasks, _, _ = component_case
|
|
child = service.for_project_task(tasks[0].task_id)
|
|
handoff = child._quick_run_preparer.ensure_batch_handoff(tasks[0].task_id,
|
|
child.projects(tasks[0].task_id), child._execution_rules(tasks[0].task_id))
|
|
first = read_command_rows(handoff.command_path)[0]
|
|
overlap = dict(first, job_id='overlap', new_part='OTHER')
|
|
with pytest.raises(TaskCenterError, match='quick_run_uncertain'):
|
|
child._quick_run_preparer.journal.bind(tasks[0].task_id, (first, overlap), {})
|