Files
dxdesigner-part-replacement/tests/trial_task_center/test_batch.py
T

1095 lines
46 KiB
Python

from pathlib import Path
import json
import subprocess
from threading import Event
import time
import tracemalloc
import pytest
from dx_productivity.trial_task_center.errors import TaskCenterError
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer, _ProjectDiscovery
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
def setup_queue(tmp_path, states, *, stop=None, missing_close=False, messages=None):
root = tmp_path / 'projects'
for index in range(len(states)):
project = root / str(index) / (str(index) + '.prj')
project.parent.mkdir(parents=True)
project.write_text('disposable project')
data = tmp_path / 'data'
calls = []
def worker(command, timeout):
job_id = command[-1]
assert (data / 'quick-run/batch.request').read_text() == job_id
index = len(calls)
state = states[index]
message = messages[index] if messages is not None else 'result'
calls.append(job_id)
with (data / 'quick-run/status.tsv').open('a', encoding='utf-8') as stream:
if state == 'saved_ok':
stream.write(f'{job_id}\tawaiting_native_replace\t\tcaptured\n')
code = '' if missing_close else 'batch_closed'
stream.write(f'{job_id}\t{state}\t{code}\t{message}\n')
if stop is not None and len(calls) == 1:
stop.set()
return subprocess.CompletedProcess(command, 1 if state == 'hard_failure' else 0, '', '')
preparer = QuickRunPreparer(
data,
process_runner=worker,
cscript_resolver=lambda: Path('cscript.exe'),
sheet_discoverer=lambda project: (('Main', '1'),),
)
service = TaskCenterService(TaskStore(tmp_path / 'tasks.db'), configure_logging(data), quick_run_preparer=preparer)
task = service.create_task('Batch')
service.scan_projects(task.task_id, root)
for project in service.projects(task.task_id):
service.set_project_selected(project.project_id, True)
service.add_rule(task.task_id, 'OLD', 'NEW')
return service, task, calls
def run_queue(service, task, stop=None):
progress = service.quick_run_progress(task.task_id)
expected = (str(progress.next_project_path), 'OLD', 'NEW', 'preserve')
return service.execute_quick_run_queue(task.task_id, expected_item=expected, stop_event=stop or Event())
def test_native_mutation_failure_stops_before_next_batch_step(tmp_path):
service, task, calls = setup_queue(tmp_path, ('batch_failed', 'saved_ok'))
original_worker = service._quick_run_preparer._process_runner
def failed_after_mutation(command, timeout):
root = Path(command[3])
job = command[-1]
with (root / 'status.tsv').open('a', encoding='utf-8') as stream:
stream.write(f'{job}\tawaiting_native_replace\t\tsnapshot captured\n')
(root / f'snapshot-{job}.tsv.native.json').write_text(
json.dumps({'ok': False, 'stage': 'pin_promotion_started'}), encoding='utf-8')
return original_worker(command, timeout)
service._quick_run_preparer._process_runner = failed_after_mutation
with pytest.raises(TaskCenterError) as raised:
run_queue(service, task)
assert raised.value.code == 'quick_run_uncertain'
assert len(calls) == 1
assert (tmp_path / 'data/quick-run/uncertain.flag').exists()
@pytest.mark.parametrize('states', [('no_match',) * 20, ('no_match', 'saved_ok', 'no_match', 'saved_ok')])
def test_queue_continues_after_misses_and_successes(tmp_path, states):
service, task, calls = setup_queue(tmp_path, states)
result = run_queue(service, task)
assert len(calls) == len(states)
assert len(set(calls)) == len(calls)
assert result.progress.queue_complete
assert result.progress.no_match_items == states.count('no_match')
assert result.progress.saved_items == states.count('saved_ok')
for project, state in zip(service.projects(task.task_id), states):
assert project.summary == ('quick_run_result:0:1:saved' if state == 'no_match' else 'quick_run_result:1:0:saved')
def test_no_match_is_recorded_as_information_not_warning(tmp_path):
service, task, _ = setup_queue(tmp_path, ('no_match',))
run_queue(service, task)
events_path = tmp_path / 'data/tasks' / task.task_id / 'events.jsonl'
events = [json.loads(line) for line in events_path.read_text(encoding='utf-8').splitlines()]
executed = [event for event in events if event['operation'] == 'quick_run_executed']
assert len(executed) == 1
assert executed[0]['level'] == 'INFO'
assert executed[0]['details']['state'] == 'no_match'
def test_discovery_inventory_completes_definite_misses_without_reopening_projects(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'))
preparer = service._quick_run_preparer
preparer._sheet_discoverer = None
preparer._discover_project_sheets = lambda _project, _parts: _ProjectDiscovery(
(('Main', '1'),),
{('Main', '1'): frozenset()},
)
result = run_queue(service, task)
assert result.progress.queue_complete
assert result.progress.no_match_items == 2
assert calls == []
assert all(project.summary == 'quick_run_result:0:1:saved' for project in service.projects(task.task_id))
events = [
json.loads(line)
for line in (tmp_path / 'data/tasks' / task.task_id / 'events.jsonl').read_text(encoding='utf-8').splitlines()
]
prefiltered = [event for event in events if event['operation'] == 'quick_run_inventory_prefiltered']
assert len(prefiltered) == 1
assert prefiltered[0]['details']['prefiltered_items'] == 2
def test_discovery_inventory_executes_present_sources_and_skips_only_absent_sources(tmp_path):
service, task, calls = setup_queue(tmp_path, ('saved_ok',))
service.add_rule(task.task_id, 'ABSENT', 'OTHER')
preparer = service._quick_run_preparer
preparer._sheet_discoverer = None
preparer._discover_project_sheets = lambda _project, _parts: _ProjectDiscovery(
(('Main', '1'),),
{('Main', '1'): frozenset({'old'})},
)
def worker(command, timeout):
del timeout
job_id = command[-1]
calls.append(job_id)
with (tmp_path / 'data/quick-run/status.tsv').open('a', encoding='utf-8') as stream:
stream.write(f'{job_id}\tawaiting_native_replace\t\tcaptured\n')
stream.write(f'{job_id}\tsaved_ok\tbatch_closed\tsaved\n')
return subprocess.CompletedProcess(command, 0, '', '')
calls.clear()
preparer._process_runner = worker
result = run_queue(service, task)
assert result.progress.queue_complete
assert result.progress.saved_items == 1
assert result.progress.no_match_items == 1
assert len(calls) == 1
def test_batch_discovers_before_lazy_backup_and_reuses_backup_for_shared_root(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.batch as batch_module
service, task, _ = setup_queue(tmp_path, ('no_match', 'no_match'))
events = []
preparer = service._quick_run_preparer
original_worker = preparer._process_runner
def discover(project):
events.append(f'discover:{project.name}')
return (('Main', '1'),)
def backup(_data_root, project, _destination):
events.append(f'backup:{project.name}')
def worker(command, timeout):
rows = (tmp_path / 'data/quick-run/current-command.tsv').read_text(encoding='utf-8').splitlines()
current = dict(zip(rows[0].split('\t'), rows[1].split('\t'), strict=True))
events.append(f"worker:{Path(current['project_path']).name}")
return original_worker(command, timeout)
preparer._sheet_discoverer = discover
preparer._process_runner = worker
monkeypatch.setattr(batch_module, '_backup_project_root', backup)
run_queue(service, task)
assert events[:2] == ['discover:0.prj', 'discover:1.prj']
assert events.index('backup:0.prj') < events.index('worker:0.prj')
assert events.index('backup:1.prj') < events.index('worker:1.prj')
assert events.index('worker:0.prj') < events.index('worker:1.prj')
def test_next_project_backup_overlaps_current_project_execution(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.batch as batch_module
service, task, _ = setup_queue(tmp_path, ('no_match', 'no_match'))
preparer = service._quick_run_preparer
original_worker = preparer._process_runner
next_backup_started = Event()
current_worker_started = Event()
def backup(_data_root, project, _destination):
if project.name == '1.prj':
next_backup_started.set()
assert current_worker_started.wait(2)
def worker(command, timeout):
rows = (tmp_path / 'data/quick-run/current-command.tsv').read_text(encoding='utf-8').splitlines()
current = dict(zip(rows[0].split('\t'), rows[1].split('\t'), strict=True))
if Path(current['project_path']).name == '0.prj':
current_worker_started.set()
assert next_backup_started.wait(2)
return original_worker(command, timeout)
preparer._process_runner = worker
monkeypatch.setattr(batch_module, '_backup_project_root', backup)
result = run_queue(service, task)
assert result.progress.queue_complete
assert next_backup_started.is_set()
assert current_worker_started.is_set()
def test_prefetched_backup_failure_can_be_overridden_without_stopping_the_queue(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.batch as batch_module
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'))
def backup(_data_root, project, _destination):
if project.name == '1.prj':
raise TaskCenterError('quick_run_backup', 'prefetched backup failed')
monkeypatch.setattr(batch_module, '_backup_project_root', backup)
progress = service.quick_run_progress(task.task_id)
result = service.execute_quick_run_queue(
task.task_id,
expected_item=(str(progress.next_project_path), 'OLD', 'NEW', 'preserve'),
stop_event=Event(),
continue_after_backup_failure=True,
)
assert result.progress.queue_complete
assert len(calls) == 2
assert tuple(path.name for path in result.unbacked_project_paths) == ('1.prj',)
def test_prefetched_backup_failure_stops_before_the_unbacked_project(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.batch as batch_module
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'))
def backup(_data_root, project, _destination):
if project.name == '1.prj':
raise TaskCenterError('quick_run_backup', 'prefetched backup failed')
monkeypatch.setattr(batch_module, '_backup_project_root', backup)
with pytest.raises(TaskCenterError, match='prefetched backup failed'):
run_queue(service, task)
assert len(calls) == 1
def test_large_batch_reuses_queue_parsing_and_groups_progress_linearly(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.quick_run as quick_run_module
item_count = 40
service, task, calls = setup_queue(tmp_path, ('no_match',) * item_count)
initial = service.quick_run_progress(task.task_id)
command_reads = 0
status_reads = 0
original_commands = quick_run_module._read_commands
original_statuses = quick_run_module._read_status_details
def counted_commands(path):
nonlocal command_reads
command_reads += 1
return original_commands(path)
def counted_statuses(path):
nonlocal status_reads
status_reads += 1
return original_statuses(path)
monkeypatch.setattr(quick_run_module, '_read_commands', counted_commands)
monkeypatch.setattr(quick_run_module, '_read_status_details', counted_statuses)
result = service.execute_quick_run_queue(
task.task_id,
expected_item=(str(initial.next_project_path), 'OLD', 'NEW', 'preserve'),
stop_event=Event(),
)
assert result.progress.queue_complete
assert len(calls) == item_count
assert command_reads <= 2
assert status_reads <= 2
path_key_calls = 0
original_path_key = quick_run_module._path_key
def counted_path_key(path):
nonlocal path_key_calls
path_key_calls += 1
return original_path_key(path)
monkeypatch.setattr(quick_run_module, '_path_key', counted_path_key)
assert service.quick_run_progress(task.task_id).queue_complete
assert path_key_calls <= item_count * 6
def test_batch_clears_stale_state_before_a_fresh_item(tmp_path):
service, task, _ = setup_queue(tmp_path, ('no_match',))
initial = service.quick_run_progress(task.task_id)
state_path = tmp_path / 'data/quick-run/current-state.tsv'
state_path.parent.mkdir(parents=True, exist_ok=True)
state_path.write_text('job_id\tstate\tcode\tmessage\r\nstale\tsaved_ok\tbatch_closed\told\r\n')
original_worker = service._quick_run_preparer._process_runner
state_visible_to_worker = []
def worker(command, timeout):
state_visible_to_worker.append(state_path.exists())
return original_worker(command, timeout)
service._quick_run_preparer._process_runner = worker
result = service.execute_quick_run_queue(
task.task_id,
expected_item=(str(initial.next_project_path), 'OLD', 'NEW', 'preserve'),
stop_event=Event(),
)
assert result.progress.queue_complete
assert state_visible_to_worker == [False]
def test_batch_clears_worker_current_state_after_saved_completion(tmp_path):
service, task, _ = setup_queue(tmp_path, ('saved_ok',))
state_path = tmp_path / 'data/quick-run/current-state.tsv'
original_worker = service._quick_run_preparer._process_runner
def worker(command, timeout):
result = original_worker(command, timeout)
job_id = command[-1]
state_path.write_text(
f'job_id\tstate\tcode\tmessage\r\n{job_id}\tawaiting_native_replace\t\tcaptured\r\n',
encoding='utf-8',
)
return result
service._quick_run_preparer._process_runner = worker
result = run_queue(service, task)
assert result.progress.queue_complete
assert not state_path.exists()
def test_thousand_item_multisheet_mixed_queue_has_bounded_runtime_and_memory(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.batch as batch_module
project_count = 20
sheet_count = 5
rule_count = 10
root = tmp_path / 'projects'
for index in range(project_count):
project = root / f'{index:02d}' / f'{index:02d}.prj'
project.parent.mkdir(parents=True)
project.write_text('disposable project')
data = tmp_path / 'data'
calls = []
def worker(command, timeout):
del timeout
job_id = command[-1]
index = len(calls)
calls.append(job_id)
with (data / 'quick-run/status.tsv').open('a', encoding='utf-8') as stream:
if index % 11 == 0:
stream.write(f'{job_id}\tawaiting_native_replace\t\tcaptured\n')
stream.write(f'{job_id}\tsaved_ok\tbatch_closed\tsaved\n')
else:
stream.write(f'{job_id}\tno_match\tbatch_closed\tnot found\n')
return subprocess.CompletedProcess(command, 0, '', '')
preparer = QuickRunPreparer(
data,
process_runner=worker,
cscript_resolver=lambda: Path('cscript.exe'),
sheet_discoverer=lambda _project: tuple(('Main', str(index + 1)) for index in range(sheet_count)),
)
service = TaskCenterService(TaskStore(tmp_path / 'tasks.db'), configure_logging(data), quick_run_preparer=preparer)
task = service.create_task('Stress')
service.scan_projects(task.task_id, root)
service.select_all_projects(task.task_id)
for index in range(rule_count):
service.add_rule(task.task_id, f'OLD-{index:02d}', f'NEW-{index:02d}')
monkeypatch.setattr(batch_module, '_backup_project_root', lambda *_args: None)
initial = service.quick_run_progress(task.task_id)
expected = (str(initial.next_project_path), 'OLD-00', 'NEW-00', 'preserve')
tracemalloc.start()
started = time.perf_counter()
result = service.execute_quick_run_queue(task.task_id, expected_item=expected, stop_event=Event())
elapsed = time.perf_counter() - started
_, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
total = project_count * sheet_count * rule_count
saved = len(range(0, total, 11))
(tmp_path / 'stress-metrics.json').write_text(json.dumps({
'mode': 'simulated_worker_with_tracemalloc', 'projects': project_count,
'sheets_per_project': sheet_count, 'rules_per_sheet': rule_count,
'steps': total, 'saved_steps': saved, 'elapsed_seconds': elapsed,
'peak_bytes': peak, 'steps_per_second': total / elapsed,
}, indent=2), encoding='utf-8')
assert result.progress.queue_complete
assert result.progress.total_items == total
assert result.progress.saved_items == saved
assert result.progress.no_match_items == total - saved
assert len(calls) == total and len(set(calls)) == total
assert elapsed < 30
assert peak < 128 * 1024 * 1024
def test_batch_marks_a_deleted_current_command_as_uncertain(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match',))
original_worker = service._quick_run_preparer._process_runner
def delete_current_command(command, timeout):
result = original_worker(command, timeout)
(tmp_path / 'data/quick-run/current-command.tsv').unlink()
return result
service._quick_run_preparer._process_runner = delete_current_command
with pytest.raises(TaskCenterError) as raised:
run_queue(service, task)
assert raised.value.code == 'quick_run_uncertain'
assert len(calls) == 1
assert (tmp_path / 'data/quick-run/uncertain.flag').is_file()
def test_batch_stops_if_command_queue_changes_between_items(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'))
original_worker = service._quick_run_preparer._process_runner
def mutate_queue_after_first_item(command, timeout):
result = original_worker(command, timeout)
if len(calls) == 1:
command_path = tmp_path / 'data/quick-run/command.tsv'
command_path.write_text(
command_path.read_text(encoding='utf-8').replace('\tNEW\t', '\tCHANGED\t'),
encoding='utf-8',
)
return result
service._quick_run_preparer._process_runner = mutate_queue_after_first_item
with pytest.raises(TaskCenterError, match='quick_run_selection_changed'):
run_queue(service, task)
assert len(calls) == 1
def test_batch_returns_nc_synchronization_messages_for_ui_log(tmp_path):
messages = (
'Native replacement passed. NC synced: R1 R0603/NC -> R0805/NC (detected /NC and synchronized)',
'Native replacement passed.',
)
service, task, _ = setup_queue(tmp_path, ('saved_ok', 'saved_ok'), messages=messages)
result = run_queue(service, task)
assert result.item_messages == (messages[0],)
def test_real_failure_isolated_from_later_project(tmp_path):
from dx_productivity.trial_task_center.models import ProjectStatus, TaskStatus
service, task, calls = setup_queue(tmp_path, ('no_match', 'batch_failed', 'saved_ok'))
result = run_queue(service, task)
assert result.progress.queue_complete
assert len(calls) == 3
projects = service.projects(task.task_id)
assert projects[0].status is ProjectStatus.COMPLETED
assert projects[1].status is ProjectStatus.FAILED
assert projects[2].status is ProjectStatus.COMPLETED
assert service.get_task(task.task_id).status is TaskStatus.RUNNING
assert service.quick_run_phase(task.task_id) == 'retry'
def test_batch_failure_marks_project_failed_and_continues_to_next_project(tmp_path):
from dx_productivity.trial_task_center.models import ProjectStatus, TaskStatus
service, task, calls = setup_queue(tmp_path, ('batch_failed', 'saved_ok'))
result = run_queue(service, task)
assert result.progress.queue_complete
assert len(calls) == 2
projects = service.projects(task.task_id)
assert projects[0].status is ProjectStatus.FAILED
assert projects[0].summary == 'quick_run_result:0:0:failed|Main:1 result'
assert projects[1].status is ProjectStatus.COMPLETED
assert service.get_task(task.task_id).status is TaskStatus.RUNNING
assert service.quick_run_phase(task.task_id) == 'retry'
def test_part_label_readback_failure_is_actionable_in_project_summary(tmp_path):
from dx_productivity.trial_task_center.models import ProjectStatus
message = (
'project was saved before readback verification failed; '
'Part Label readback failed: attribute is unavailable; refdes=R17; uid=901'
)
service, task, _ = setup_queue(tmp_path, ('batch_saved_unverified',), messages=(message,))
run_queue(service, task)
project = service.projects(task.task_id)[0]
assert project.status is ProjectStatus.FAILED
assert '工程已保存,位号 R17:Part Label 回读失败(目标属性缺失)' in project.summary
assert '本项未保存' not in project.summary
def test_missing_project_is_skipped_and_other_projects_continue(tmp_path):
from dx_productivity.trial_task_center.models import ProjectStatus, TaskStatus
service, task, calls = setup_queue(tmp_path, ('saved_ok', 'saved_ok'))
projects = service.projects(task.task_id)
missing = projects[0].path
missing.unlink()
def discover(project):
if project == missing:
raise FileNotFoundError(project)
return (('Main', '1'),)
service._quick_run_preparer._sheet_discoverer = discover
result = run_queue(service, task)
assert result.progress.queue_complete
assert len(calls) == 1
final_projects = service.projects(task.task_id)
assert final_projects[0].status is ProjectStatus.FAILED
assert '工程文件不存在,已跳过' in final_projects[0].summary
assert final_projects[1].status is ProjectStatus.COMPLETED
assert service.get_task(task.task_id).status is TaskStatus.RUNNING
def test_batch_failure_continues_with_next_rule_in_same_project(tmp_path):
from dx_productivity.trial_task_center.models import ProjectStatus, TaskStatus
root = tmp_path / 'projects'
project_path = root / 'one' / 'one.prj'
project_path.parent.mkdir(parents=True)
project_path.write_text('disposable project')
data = tmp_path / 'data'
calls = []
def worker(command, timeout):
del timeout
job_id = command[-1]
state = ('batch_failed', 'saved_ok')[len(calls)]
calls.append(job_id)
with (data / 'quick-run/status.tsv').open('a', encoding='utf-8') as stream:
if state == 'saved_ok':
stream.write(f'{job_id}\tawaiting_native_replace\t\tcaptured\n')
stream.write(f'{job_id}\t{state}\tbatch_closed\t{state} detail\n')
return subprocess.CompletedProcess(command, 0, '', '')
preparer = QuickRunPreparer(
data,
process_runner=worker,
cscript_resolver=lambda: Path('cscript.exe'),
sheet_discoverer=lambda project: (('Main', '1'),),
)
service = TaskCenterService(TaskStore(tmp_path / 'tasks.db'), configure_logging(data), quick_run_preparer=preparer)
task = service.create_task('Batch')
service.scan_projects(task.task_id, root)
project = service.projects(task.task_id)[0]
service.set_project_selected(project.project_id, True)
service.add_rule(task.task_id, 'OLD-1', 'NEW-1')
service.add_rule(task.task_id, 'OLD-2', 'NEW-2')
progress = service.quick_run_progress(task.task_id)
expected = (str(progress.next_project_path), 'OLD-1', 'NEW-1', 'preserve')
result = service.execute_quick_run_queue(task.task_id, expected_item=expected, stop_event=Event())
assert result.progress.queue_complete
assert len(calls) == 2
assert result.progress.saved_items == 1
assert result.progress.failed_items == 1
assert service.projects(task.task_id)[0].status is ProjectStatus.FAILED
assert service.get_task(task.task_id).status is TaskStatus.RUNNING
assert service.quick_run_phase(task.task_id) == 'retry'
status_text = (data / 'quick-run/status.tsv').read_text(encoding='utf-8')
assert 'batch_skipped' not in status_text
assert result.item_messages == ('batch_failed detail',)
events = [
json.loads(line)
for line in (data / 'tasks' / task.task_id / 'events.jsonl').read_text(encoding='utf-8').splitlines()
]
failures = [event for event in events if event['operation'] == 'quick_run_executed' and event['level'] == 'WARNING']
assert len(failures) == 1
assert failures[0]['details']['state'] == 'batch_failed'
def test_retry_queue_runs_only_failed_projects_then_completes_task(tmp_path):
from dx_productivity.trial_task_center.models import ProjectStatus, TaskStatus
service, task, first_calls = setup_queue(tmp_path, ('batch_failed', 'saved_ok'))
run_queue(service, task)
projects = service.projects(task.task_id)
failed_path = projects[0].path
completed_path = projects[1].path
rule = service.rules(task.task_id)[0]
service.update_rule(
rule.rule_id,
old_part_number='OLD',
new_part_number='RETRY-NEW',
enabled=True,
sync_nc=False,
)
service.set_copy_part_number_to_value(task.task_id, True)
retry_progress = service.prepare_failed_quick_run(task.task_id)
assert retry_progress.total_items == 1
assert retry_progress.next_project_path == failed_path
assert retry_progress.next_new_part_number == 'RETRY-NEW'
assert service.projects(task.task_id)[0].status is ProjectStatus.PENDING
command_fields = (tmp_path / 'data/quick-run/command.tsv').read_text(encoding='utf-8').splitlines()[1].split('\t')
assert command_fields[-4:] == ['part_label', '', '0', 'part_label']
retry_calls = []
def retry_worker(command, timeout):
del timeout
job_id = command[-1]
retry_calls.append(job_id)
with (tmp_path / 'data/quick-run/status.tsv').open('a', encoding='utf-8') as stream:
stream.write(f'{job_id}\tawaiting_native_replace\t\tcaptured\n')
stream.write(f'{job_id}\tsaved_ok\tbatch_closed\tretry passed\n')
return subprocess.CompletedProcess(command, 0, '', '')
service._quick_run_preparer._process_runner = retry_worker
expected = (str(failed_path), 'OLD', 'RETRY-NEW', 'part_label')
result = service.execute_quick_run_queue(task.task_id, expected_item=expected, stop_event=Event())
assert result.progress.queue_complete
assert len(first_calls) == 2
assert len(retry_calls) == 1
final_projects = service.projects(task.task_id)
assert [project.path for project in final_projects if project.status is ProjectStatus.COMPLETED] == [
failed_path,
completed_path,
]
assert service.get_task(task.task_id).status is TaskStatus.COMPLETED
def test_pause_then_resume_never_repeats_finished_step(tmp_path):
stop = Event()
service, task, calls = setup_queue(tmp_path, ('no_match', 'saved_ok', 'no_match'), stop=stop)
result = run_queue(service, task, stop)
assert result.paused and len(calls) == 1
assert result.progress.completed_items == 1
resumed = run_queue(service, task)
assert resumed.progress.queue_complete
assert len(calls) == 3 and len(set(calls)) == 3
def test_multisheet_queue_addresses_each_page_and_resumes_without_repetition(tmp_path):
root = tmp_path / 'projects'
root.mkdir()
project_path = root / 'multi.prj'
project_path.touch()
data = tmp_path / 'data'
calls = []
current_commands = []
stop = Event()
def worker(command, timeout):
del timeout
job_id = command[-1]
calls.append(job_id)
command_lines = (data / 'quick-run/current-command.tsv').read_text(encoding='utf-8').splitlines()
assert len(command_lines) == 2
header = command_lines[0].split('\t')
current = dict(zip(header, command_lines[1].split('\t'), strict=True))
assert current['job_id'] == job_id
current_commands.append(current)
with (data / 'quick-run/status.tsv').open('a', encoding='utf-8') as stream:
stream.write(f'{job_id}\tno_match\tbatch_closed\tnot found\n')
if len(calls) == 2:
stop.set()
return subprocess.CompletedProcess(command, 0, '', '')
preparer = QuickRunPreparer(
data,
process_runner=worker,
cscript_resolver=lambda: Path('cscript.exe'),
sheet_discoverer=lambda project: (('Main', '1'), ('Main', '2')),
)
service = TaskCenterService(TaskStore(tmp_path / 'tasks.db'), configure_logging(data), quick_run_preparer=preparer)
task = service.create_task('Multisheet')
project = service.scan_projects(task.task_id, root)[0]
service.set_project_selected(project.project_id, True)
service.set_copy_part_number_to_value(task.task_id, True)
service.add_rule(task.task_id, 'OLD-1', 'NEW-1')
service.add_rule(task.task_id, 'OLD-2', 'NEW-2')
initial = service.quick_run_progress(task.task_id)
first = service.execute_quick_run_queue(
task.task_id,
expected_item=(str(initial.next_project_path), 'OLD-1', 'NEW-1', 'part_label'),
stop_event=stop,
)
assert first.paused and first.progress.completed_items == 2
assert first.progress.total_items == 4
assert (first.progress.next_schematic_name, first.progress.next_sheet_number) == ('Main', '2')
stop.clear()
resumed = service.quick_run_progress(task.task_id)
completed = service.execute_quick_run_queue(
task.task_id,
expected_item=(str(resumed.next_project_path), 'OLD-1', 'NEW-1', 'part_label'),
stop_event=stop,
)
assert completed.progress.queue_complete
assert completed.progress.no_match_items == 4
assert len(calls) == 4 and len(set(calls)) == 4
command_lines = (data / 'quick-run/command.tsv').read_text(encoding='utf-8').splitlines()
header = command_lines[0].split('\t')
rows = [dict(zip(header, line.split('\t'), strict=True)) for line in command_lines[1:]]
assert [(row['schematic_name'], row['sheet_number'], row['old_part']) for row in rows] == [
('Main', '1', 'OLD-1'), ('Main', '1', 'OLD-2'),
('Main', '2', 'OLD-1'), ('Main', '2', 'OLD-2'),
]
assert [
(row['schematic_name'], row['sheet_number'], row['old_part'], row['value_mode'])
for row in current_commands
] == [
('Main', '1', 'OLD-1', 'part_label'), ('Main', '1', 'OLD-2', 'part_label'),
('Main', '2', 'OLD-1', 'part_label'), ('Main', '2', 'OLD-2', 'part_label'),
]
def test_sheet_discovery_failure_stops_before_queue_or_worker(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match',))
def fail_discovery(project):
raise TaskCenterError('quick_run_sheet_discovery', f'cannot inspect {project}')
service._quick_run_preparer._sheet_discoverer = fail_discovery
with pytest.raises(TaskCenterError, match='quick_run_sheet_discovery'):
run_queue(service, task)
assert not calls
assert not (tmp_path / 'data/quick-run/command.tsv').exists()
def test_cancel_before_start_executes_nothing(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match',))
stop = Event()
stop.set()
assert run_queue(service, task, stop).paused
assert not calls
def test_missing_save_close_proof_blocks_continuation(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'), missing_close=True)
with pytest.raises(TaskCenterError, match='quick_run_uncertain'):
run_queue(service, task)
assert len(calls) == 1
assert service.has_interrupted_quick_run(task.task_id)
def test_confirmation_mismatch_cannot_start_batch(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match',))
with pytest.raises(TaskCenterError, match='quick_run_selection_changed'):
service.execute_quick_run_queue(task.task_id, expected_item=('wrong', 'OLD', 'NEW', 'preserve'), stop_event=Event())
assert not calls
def test_missing_project_backup_does_not_start_worker(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match',))
service.projects(task.task_id)[0].path.unlink()
with pytest.raises(TaskCenterError, match='quick_run_backup'):
run_queue(service, task)
assert not calls
def test_projects_in_same_directory_share_one_verified_backup(tmp_path):
root = tmp_path / 'projects'
root.mkdir()
(root / 'one.prj').touch()
(root / 'two.prj').touch()
data = tmp_path / 'data'
def worker(command, timeout):
del timeout
with (data / 'quick-run/status.tsv').open('a', encoding='utf-8') as stream:
stream.write(f'{command[-1]}\tno_match\tbatch_closed\tnot found\n')
return subprocess.CompletedProcess(command, 0, '', '')
preparer = QuickRunPreparer(
data,
process_runner=worker,
cscript_resolver=lambda: Path('cscript.exe'),
sheet_discoverer=lambda project: (('Main', '1'),),
)
service = TaskCenterService(TaskStore(tmp_path / 'tasks.db'), configure_logging(data), quick_run_preparer=preparer)
task = service.create_task('Shared root')
service.scan_projects(task.task_id, root)
service.select_all_projects(task.task_id)
service.add_rule(task.task_id, 'OLD', 'NEW')
result = run_queue(service, task)
audit = data / 'quick-run' / 'batch-backups'
assert result.progress.queue_complete
assert len(tuple(audit.glob('project-*'))) == 1
def test_pause_and_resume_does_not_repeat_completed_project_backup(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.batch as batch_module
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'))
backups = []
stop = Event()
original_backup = batch_module._backup_project_root
original_worker = service._quick_run_preparer._process_runner
def backup(data_root, project, destination):
backups.append(project)
return original_backup(data_root, project, destination)
def stop_after_first(command, timeout):
result = original_worker(command, timeout)
stop.set()
return result
monkeypatch.setattr(batch_module, '_backup_project_root', backup)
service._quick_run_preparer._process_runner = stop_after_first
first = run_queue(service, task, stop)
assert first.paused
assert len(backups) == 2
service._quick_run_preparer._process_runner = original_worker
second = run_queue(service, task)
assert second.progress.queue_complete
assert len(backups) == 2
assert len({path.resolve().parent for path in backups}) == 2
def test_schematic_backup_excludes_generated_and_pcb_trees(tmp_path):
import dx_productivity.trial_task_center.batch as batch_module
project_root = tmp_path / 'project'
project_root.mkdir()
project = project_root / 'design.prj'
project.write_text('schematic project', encoding='utf-8')
(project_root / 'design.dxp').write_text('settings', encoding='utf-8')
(project_root / 'database').mkdir()
(project_root / 'database/icdb.dat').write_bytes(b'schematic database')
(project_root / 'hdl').mkdir()
(project_root / 'hdl/design.vhd').write_text('entity design is end;', encoding='utf-8')
for excluded in ('PCB', 'CES', 'ProjectBackup', 'backups', 'Log Files'):
folder = project_root / excluded / 'nested'
folder.mkdir(parents=True)
(folder / 'large-generated.bin').write_bytes(b'x' * 1024)
(project_root / 'database/cdbsvr/log').mkdir(parents=True)
(project_root / 'database/cdbsvr/log/runtime.log').write_text('runtime', encoding='utf-8')
destination = tmp_path / 'data/quick-run-history/batch-test/project-1'
batch_module._backup_project_root_once(tmp_path / 'data', project, destination)
assert (destination / 'design.prj').read_text(encoding='utf-8') == 'schematic project'
assert (destination / 'database/icdb.dat').read_bytes() == b'schematic database'
assert (destination / 'hdl/design.vhd').is_file()
assert not (destination / 'PCB').exists()
assert not (destination / 'CES').exists()
assert not (destination / 'ProjectBackup').exists()
assert not (destination / 'backups').exists()
assert not (destination / 'Log Files').exists()
assert not (destination / 'database/cdbsvr').exists()
manifest = json.loads((destination / '.dxpartreplace-backup.json').read_text(encoding='utf-8'))
assert manifest['scope'] == 'dxdesigner_schematic_essentials'
assert manifest['included_file_count'] == 4
assert {entry['path'] for entry in manifest['files']} == {
'database/icdb.dat', 'design.dxp', 'design.prj', 'hdl/design.vhd',
}
assert {'PCB', 'CES', 'ProjectBackup', 'backups', 'Log Files', 'database/cdbsvr'} <= set(
manifest['excluded_directories']
)
def test_backup_link_rejection_uses_backup_error_code(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.schematic_backup as backup_module
service, task, calls = setup_queue(tmp_path, ('no_match',))
monkeypatch.setattr(backup_module, '_is_link_or_reparse', lambda _path: True)
with pytest.raises(TaskCenterError) as raised:
run_queue(service, task)
assert raised.value.code == 'quick_run_backup'
assert not calls
def test_explicit_backup_failure_override_continues_and_is_audited(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.batch as batch_module
service, task, calls = setup_queue(tmp_path, ('no_match',))
def fail_backup(*_args):
raise TaskCenterError('quick_run_backup', 'simulated backup failure')
monkeypatch.setattr(batch_module, '_backup_project_root', fail_backup)
progress = service.quick_run_progress(task.task_id)
result = service.execute_quick_run_queue(
task.task_id,
expected_item=(str(progress.next_project_path), 'OLD', 'NEW', 'preserve'),
stop_event=Event(),
continue_after_backup_failure=True,
)
assert result.progress.queue_complete
assert result.unbacked_project_paths == (progress.next_project_path,)
assert len(calls) == 1
events_path = tmp_path / 'data/tasks' / task.task_id / 'events.jsonl'
events = [json.loads(line) for line in events_path.read_text(encoding='utf-8').splitlines()]
override = [event for event in events if event['operation'] == 'quick_run_backup_override']
assert len(override) == 1
assert override[0]['level'] == 'WARNING'
assert override[0]['details']['rollback_available'] is False
assert override[0]['details']['state'] == 'continued_without_backup'
def test_backup_retries_transient_file_lock_before_discovery(tmp_path, monkeypatch):
import dx_productivity.trial_task_center.batch as batch_module
attempts = []
delays = []
def attempt(*_args):
attempts.append(True)
if len(attempts) < 3:
raise PermissionError("locked")
monkeypatch.setattr(batch_module, '_backup_project_root_once', attempt)
monkeypatch.setattr(batch_module.time, 'sleep', delays.append)
batch_module._backup_project_root(tmp_path, tmp_path / 'one.prj', tmp_path / 'quick-run-history/copy')
assert len(attempts) == 3
assert delays == [0.4, 0.8]
def test_batch_failure_hints_do_not_suggest_unsafe_takeover():
from dx_productivity.trial_task_center.quick_run import _session_failure_message
assert '不会接管' in _session_failure_message('batch cannot take over an already open project stage=check_project')
assert '重新枚举全部图页' in _session_failure_message('project has multiple sheets stage=open_sheet')
def test_monitor_fault_is_protected_but_not_reported_as_timeout(tmp_path):
from dx_productivity.trial_task_center.worker_monitor import WorkerMonitorError
service, task, calls = setup_queue(tmp_path, ('no_match',))
def fail_monitor(command, timeout):
raise WorkerMonitorError('disk failure after launch')
service._quick_run_preparer._process_runner = fail_monitor
with pytest.raises(TaskCenterError, match='并非无进度超时'):
run_queue(service, task)
assert service.has_interrupted_quick_run(task.task_id)
@pytest.mark.parametrize('code, saved', [('recovery_verified', True), ('', False)])
def test_legacy_results_require_saved_recovery_proof(tmp_path, code, saved):
service, task, calls = setup_queue(tmp_path, ('no_match',))
run_queue(service, task)
status = tmp_path / 'data/quick-run/status.tsv'
status.write_text(status.read_text().replace('no_match\tbatch_closed', 'restored_ok\t' + code))
progress = service.quick_run_progress(task.task_id)
assert progress.saved_items == int(saved)
assert progress.project_summaries[0][1] == ('quick_run_result:1:0:saved' if saved else 'quick_run_result:0:0:unsaved')
def test_boundary_pause_persists_and_can_be_restored_from_deleted(tmp_path):
from dx_productivity.trial_task_center.models import TaskStatus
stop = Event()
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'), stop=stop)
assert run_queue(service, task, stop).paused
assert service.get_task(task.task_id).status is TaskStatus.PAUSED
assert service.quick_run_progress(task.task_id).completed_items == 1
service.delete_task(task.task_id)
service.restore_task(task.task_id)
assert service.get_task(task.task_id).status is TaskStatus.PAUSED
assert run_queue(service, task).progress.queue_complete
assert len(calls) == 2
def test_manual_skip_cannot_mutate_an_executing_queue(tmp_path):
from dx_productivity.trial_task_center.service import _quick_run_lease
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'))
project = service.projects(task.task_id)[0]
with _quick_run_lease(service._logging.root):
with pytest.raises(TaskCenterError, match='quick_run_busy'):
service.skip_project(task.task_id, project.project_id)
assert service.projects(task.task_id)[0].status == project.status
@pytest.mark.parametrize('operation', ['start_task', 'pause_task', 'resume_task', 'skip_project',
'retry_project', 'capture_before', 'capture_after', 'confirm_native_attempt'])
def test_paused_automatic_queue_cannot_mix_manual_workflows(tmp_path, operation):
stop = Event()
service, task, calls = setup_queue(tmp_path, ('no_match', 'no_match'), stop=stop)
run_queue(service, task, stop)
projects = service.projects(task.task_id)
before = service.get_task(task.task_id)
arguments = [task.task_id]
keywords = {}
if operation == 'start_task':
keywords['disposable_copy_confirmed'] = True
elif operation not in {'pause_task', 'resume_task'}:
arguments.append(projects[-1].project_id)
if operation in {'capture_before', 'capture_after'}:
arguments.append(tmp_path / 'unused.json')
with pytest.raises(TaskCenterError, match='quick_run_manual_operation'):
getattr(service, operation)(*arguments, **keywords)
assert service.projects(task.task_id) == projects
assert service.get_task(task.task_id) == before
def test_automatic_queue_cannot_overlap_a_manual_active_project(tmp_path):
service, task, calls = setup_queue(tmp_path, ('no_match',))
baseline = tmp_path / 'manual-probe-baseline.json'
baseline.write_text('baseline', encoding='utf-8')
service._runner._probe_source_resolver = lambda task, project: baseline
manual = service.create_task('Manual active task')
project = service.scan_projects(manual.task_id, tmp_path / 'projects')[0]
service.set_project_selected(project.project_id, True)
service.add_rule(manual.task_id, 'OLD', 'NEW')
service.start_task(manual.task_id, disposable_copy_confirmed=True)
with pytest.raises(TaskCenterError, match='active_project_exists'):
run_queue(service, task)
assert not calls
def test_new_task_may_choose_different_value_policy_after_completed_queue(tmp_path):
service, first, calls = setup_queue(tmp_path, ('no_match', 'no_match'))
service.set_copy_part_number_to_value(first.task_id, True)
progress = service.quick_run_progress(first.task_id)
result = service.execute_quick_run_queue(first.task_id,
expected_item=(str(progress.next_project_path), 'OLD', 'NEW', 'part_label'), stop_event=Event())
assert result.progress.queue_complete
second = service.create_task('Next independent task')
for project in service.scan_projects(second.task_id, tmp_path / 'projects'):
service.set_project_selected(project.project_id, True)
service.add_rule(second.task_id, 'OLD', 'NEW')
calls.clear()
assert run_queue(service, second).progress.queue_complete
assert len(calls) == 2
assert service.has_quick_run_evidence(first.task_id)
assert service.quick_run_progress(first.task_id).queue_complete
assert service.quick_run_progress(first.task_id).completed_items == 2
assert service.quick_run_phase(first.task_id) == 'complete'
def test_incomplete_queue_cannot_be_archived_for_different_task_policy(tmp_path):
service, first, calls = setup_queue(tmp_path, ('no_match', 'no_match'))
stop = Event()
original = service._quick_run_preparer._process_runner
def stop_after_first(command, timeout):
result = original(command, timeout)
stop.set()
return result
service._quick_run_preparer._process_runner = stop_after_first
assert run_queue(service, first, stop).paused
root = tmp_path / 'data/quick-run'
before = (root / 'command.tsv').read_bytes(), (root / 'status.tsv').read_bytes()
second = service.create_task('New policy cannot abandon pending steps')
service.set_copy_part_number_to_value(second.task_id, True)
for project in service.scan_projects(second.task_id, tmp_path / 'projects'):
service.set_project_selected(project.project_id, True)
service.add_rule(second.task_id, 'OLD', 'NEW')
progress = service.quick_run_progress(second.task_id)
with pytest.raises(TaskCenterError, match='quick_run_pending'):
service.execute_quick_run_queue(second.task_id,
expected_item=(str(progress.next_project_path), 'OLD', 'NEW', 'part_label'), stop_event=Event())
assert before == ((root / 'command.tsv').read_bytes(), (root / 'status.tsv').read_bytes())
assert len(calls) == 1