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()) @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