1109 lines
47 KiB
Python
1109 lines
47 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
|
|
import dx_productivity.trial_task_center.quick_run as quick_run_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')
|
|
reads = {'_read_commands': 0, '_read_status_details': 0}
|
|
def observe(name):
|
|
original = getattr(quick_run_module, name)
|
|
def counted(*args, **kwargs):
|
|
reads[name] += 1
|
|
return original(*args, **kwargs)
|
|
monkeypatch.setattr(quick_run_module, name, counted)
|
|
for name in reads:
|
|
observe(name)
|
|
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,
|
|
'full_queue_parses': reads,
|
|
}, 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
|
|
# Wall-clock budgets depend on the machine and tracemalloc overhead. Guard
|
|
# the repeated full-file work directly; keep timings as benchmark evidence.
|
|
assert reads['_read_commands'] <= 2
|
|
assert reads['_read_status_details'] <= 2
|
|
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
|