Files
dxdesigner-part-replacement/tests/v1_1/test_nonblocking_acceptance.py
T

86 lines
4.6 KiB
Python

"""Full real scheduler/journal acceptance with a controlled native executor."""
import csv
import subprocess
from collections import Counter
from pathlib import Path
from threading import Event
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
def test_hundred_uid_batch_keeps_93_verified_items_and_isolates_unknown_writes(tmp_path):
from test_project_isolation_queue import ReleasedRuntime
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()}
uid, refdes, _ = row['target_selectors'].split('\x1f')
assert '\x1e' not in row['target_selectors']
key = row['task_id'], uid
calls.append(key)
state = outcomes.get(key, 'saved_ok')
with (root / 'status.tsv').open('a', encoding='utf-8') as stream:
if state == 'saved_ok':
stream.write(f'{command[-1]}\tawaiting_native_replace\t\tcaptured\n')
stream.write(f'{command[-1]}\t{state}\tbatch_closed\tControlled {refdes}\n')
return subprocess.CompletedProcess(command, 0, '', '')
for name in ('A', 'B', 'C', 'D'):
project = tmp_path / 'projects' / name / 'board.prj'
project.parent.mkdir(parents=True)
project.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
data = tmp_path / 'data'
database = tmp_path / 'tasks.db'
store = TaskStore(database)
preparer = QuickRunPreparer(data, process_runner=worker,
cscript_resolver=lambda: Path('controlled-native'), sheet_discoverer=lambda _: (('MAIN', '1'),))
engine = TaskCenterService(store, configure_logging(data), quick_run_preparer=preparer)
tasks = engine.create_project_tasks(tmp_path / 'projects')
counts = (48, 50, 1, 1)
for index, (task, count) in enumerate(zip(tasks, counts)):
project = engine.projects(task.task_id)[0].path
targets = tuple(ComponentTarget(project, 'MAIN', '1', f'u{i}', f'R{i}', 'OLD', '10K')
for i in range(1, count + 1))
store.record_target_inventory(task.task_id, targets)
store.replace_target_plan(task.task_id, tuple(TargetPlanRow(target, True, 'NEW') for target in targets))
if index == 0:
outcomes.update({(task.task_id, f'u{i}'): 'batch_failed' for i in range(1, 6)})
elif index in (2, 3):
outcomes[(task.task_id, 'u1')] = 'batch_saved_unverified'
gui = TaskCenterService(store, configure_logging(data), supervised=True, quick_run_preparer=preparer)
# Only the process transport/native CAD are substituted. Each child executes
# the production queue, receipts, backups, issue pass and runtime cleanup.
def supervise(operation, arguments, *, stop_event):
assert operation == 'execute_task_queue'
runtime = ReleasedRuntime(data)
runtime.desktop = None
return execute_task_queue(engine, stop_event=stop_event, runtime=runtime, **arguments)
gui._supervise = supervise
ids = tuple(task.task_id for task in tasks)
try:
result = execute_task_queue(gui, ids, stop_event=Event())
assert not result.paused
assert [entry.state for entry in result.entries] == ['failed', 'completed', 'blocked', 'blocked']
assert len(calls) == 100 and set(Counter(calls).values()) == {1}
assert (tasks[3].task_id, 'u1') in calls
records = dict(store._connection.execute('SELECT state,count(*) FROM execution_operations GROUP BY state'))
assert records == {'verified': 93, 'failed': 5, 'uncertain': 2}
resumed = execute_task_queue(gui, ids, stop_event=Event(), queue_id=result.queue_id)
assert not resumed.paused and resumed.entries[2].state == 'blocked'
assert len(calls) == 100
finally:
store.close()
reopened = TaskStore(database)
try:
assert reopened._connection.execute("SELECT count(*) FROM execution_operations WHERE state='verified'").fetchone()[0] == 93
assert reopened._connection.execute('SELECT sum(auto_retries) FROM execution_problems').fetchone()[0] == 0
finally:
reopened.close()