266 lines
16 KiB
Python
266 lines
16 KiB
Python
"""Freeze raw all-match rules into actual component identities before mutation."""
|
|
import csv
|
|
from dataclasses import replace
|
|
from pathlib import Path
|
|
import subprocess
|
|
|
|
import pytest
|
|
|
|
from dx_productivity.trial_task_center.errors import TaskCenterError
|
|
from dx_productivity.trial_task_center.execution_journal import read_command_rows
|
|
from dx_productivity.trial_task_center.models import ProjectRecord, ProjectStatus, RuleRecord
|
|
from dx_productivity.trial_task_center.quick_run import (
|
|
ProjectDiscovery, QuickRunPreparer, _path_key, _queue_matches_inputs, _read_commands,
|
|
)
|
|
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetRule
|
|
|
|
|
|
@pytest.fixture
|
|
def scope_case(tmp_path, monkeypatch):
|
|
project = tmp_path / 'projects' / 'Board' / 'board.prj'
|
|
project.parent.mkdir(parents=True)
|
|
project.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
|
|
source = tmp_path / 'runtime.vbs'
|
|
source.write_text("' controlled runtime")
|
|
selected = ProjectRecord('p', 't', 'Board', project, project.parent, True, True, ProjectStatus.PENDING, 0)
|
|
rules = (RuleRecord('r', 't', 0, 'OLD', 'NEW', True),)
|
|
components = tuple(ComponentTarget(project, 'MAIN', '1', f'uid-{i}', f'R{i}', 'OLD', '10K') for i in (1, 2))
|
|
calls, requested = [], []
|
|
def worker(command, timeout):
|
|
root = Path(command[3])
|
|
row = read_command_rows(root / 'current-command.tsv')[0]
|
|
assert row['target_selectors'], 'An empty inventory marker must never reach a mutating worker'
|
|
calls.append(row)
|
|
with (root / 'status.tsv').open('a', encoding='utf8') as stream:
|
|
stream.write(f'{command[-1]}\tawaiting_native_replace\t\tcaptured\n')
|
|
stream.write(f'{command[-1]}\tsaved_ok\tbatch_closed\tcontrolled save\n')
|
|
return subprocess.CompletedProcess(command, 0, '', '')
|
|
preparer = QuickRunPreparer(tmp_path / 'data', script_source=source,
|
|
process_runner=worker, cscript_resolver=lambda: Path('controlled-cscript'), run_token_factory=lambda: 'scope')
|
|
def discover(path, parts, *, collect_components=False, **kwargs):
|
|
requested.append(collect_components)
|
|
return ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset({'old'})}, components)
|
|
monkeypatch.setattr(preparer, 'discover_project', discover)
|
|
return preparer, selected, rules, components, requested, calls
|
|
|
|
|
|
def test_new_raw_rule_freezes_two_equal_value_targets_as_separate_uids(scope_case):
|
|
preparer, project, rules, _, requested, _ = scope_case
|
|
handoff = preparer.ensure_batch_handoff('t', (project,), rules)
|
|
rows = read_command_rows(handoff.command_path)
|
|
assert requested == [True]
|
|
assert len(rows) == 2
|
|
assert [row['target_selectors'] for row in rows] == ['uid-1\x1fR1\x1f10K', 'uid-2\x1fR2\x1f10K']
|
|
assert all(row['target_scope'] == 'targets' and row['execution_unit'] == 'component' for row in rows)
|
|
assert handoff.command_path.with_name('component-scope.json').is_file()
|
|
assert _queue_matches_inputs(handoff.command_path, _read_commands(handoff.command_path), (project,), rules)
|
|
|
|
|
|
@pytest.mark.parametrize('read_failed', [False, True])
|
|
def test_missing_project_sheet_manifest_is_a_controlled_scope_error(scope_case, read_failed):
|
|
from dx_productivity.trial_task_center.component_scope import freeze
|
|
preparer, project, rules, *_ = scope_case
|
|
key = _path_key(project.path)
|
|
discovery = preparer.discover_project(project.path, ('OLD',), collect_components=True)
|
|
with pytest.raises(TaskCenterError, match='component_scope'):
|
|
freeze((project,), rules, {}, {key: discovery}, {key} if read_failed else set(), 'preserve')
|
|
assert not (preparer.data_root / 'quick-run/command.tsv').exists()
|
|
|
|
|
|
@pytest.mark.parametrize('change', [{'custom_value_enabled': True, 'custom_value': 'changed'}, {'sync_nc': False}, {'target_cell': 'QFN'}])
|
|
def test_original_source_rule_option_changes_cannot_resume_frozen_scope(scope_case, change):
|
|
preparer, project, rules, *_ = scope_case
|
|
handoff = preparer.ensure_batch_handoff('t', (project,), rules)
|
|
changed = (replace(rules[0], **change),)
|
|
with pytest.raises(TaskCenterError, match='source|scope|来源|冻结'):
|
|
preparer.ensure_batch_handoff('t', (project,), changed)
|
|
|
|
|
|
def test_snapshot_and_resume_use_frozen_uids_without_rediscovering_changed_parts(scope_case, monkeypatch):
|
|
preparer, project, rules, *_ = scope_case
|
|
handoff = preparer.ensure_batch_handoff('t', (project,), rules)
|
|
rows = read_command_rows(handoff.command_path)
|
|
with handoff.status_path.open('a', encoding='utf8') as stream:
|
|
stream.write(f"{rows[0]['job_id']}\tsaved_ok\tbatch_closed\talready saved\n")
|
|
def forbidden(*args, **kwargs):
|
|
raise AssertionError('Completed targets now have new Part Numbers; do not rediscover them')
|
|
monkeypatch.setattr(preparer, 'discover_project', forbidden)
|
|
before = handoff.command_path.read_bytes()
|
|
assert preparer.ensure_batch_handoff('t', (project,), rules).command_path.read_bytes() == before
|
|
snapshot = preparer.read_snapshot('t', (project,), rules)
|
|
assert not snapshot.interrupted
|
|
assert snapshot.progress.total_items == 2 and snapshot.progress.completed_items == 1
|
|
assert snapshot.progress.next_old_part_number == 'OLD'
|
|
|
|
|
|
def test_mixed_no_match_is_preterminal_and_other_uid_commands_remain_dispatchable(scope_case):
|
|
preparer, project, rules, _, _, calls = scope_case
|
|
missing = RuleRecord('missing', 't', 0, 'ABSENT', 'DEST', True)
|
|
session = preparer.begin_batch_session('t', (project,), (missing, *rules))
|
|
rows = read_command_rows(session.handoff.command_path)
|
|
empty = rows[0]
|
|
assert empty['execution_unit'] == 'inventory_empty'
|
|
assert empty['target_scope'] == 'targets' and empty['target_selectors'] == ''
|
|
assert session.latest[empty['job_id']] == ('batch_skipped', 'inventory_empty')
|
|
assert session.commands[session.next_index][1] == rows[1]['job_id']
|
|
# Without a journal the normal batch gate conservatively blocks after any
|
|
# failure; dispatch the pending current command to verify its actual scope.
|
|
from dx_productivity.trial_task_center.quick_run import _write_current_command
|
|
_write_current_command(session, session.commands[session.next_index])
|
|
preparer._process_runner(('controlled', '', '', str(session.handoff.command_path.parent), rows[1]['job_id']), 10)
|
|
assert len(calls) == 1 and calls[0]['target_selectors'].startswith('uid-1\x1f')
|
|
progress = preparer.read_snapshot('t', (project,), (missing, *rules)).progress
|
|
assert progress.failed_items == 1 and progress.saved_items == 1
|
|
|
|
|
|
def test_legacy_page_all_match_queue_resumes_without_new_expansion(scope_case, monkeypatch):
|
|
preparer, project, rules, *_ = scope_case
|
|
handoff = preparer.prepare('t', (project,), rules, sheet_targets={_path_key(project.path): (('MAIN', '1'),)})
|
|
before = handoff.command_path.read_bytes()
|
|
monkeypatch.setattr(preparer, 'discover_project', lambda *args, **kwargs: pytest.fail('Legacy queue must keep its original shape'))
|
|
assert preparer.ensure_batch_handoff('t', (project,), rules).command_path.read_bytes() == before
|
|
assert 'target_scope' not in read_command_rows(handoff.command_path)[0]
|
|
assert not handoff.command_path.with_name('component-scope.json').exists()
|
|
|
|
|
|
def test_retry_preparation_inherits_frozen_scope_without_new_inventory(scope_case):
|
|
preparer, project, rules, *_ = scope_case
|
|
handoff = preparer.ensure_batch_handoff('t', (project,), rules)
|
|
staged = preparer.for_data_root(preparer.data_root / 'retry-stage')
|
|
retried = staged.prepare('t', (project,), rules,
|
|
sheet_targets={_path_key(project.path): (('MAIN', '1'),)}, component_scope_from=handoff.command_path.parent)
|
|
assert read_command_rows(retried.command_path) == read_command_rows(handoff.command_path)
|
|
assert retried.command_path.with_name('component-scope.json').read_bytes() == handoff.command_path.with_name('component-scope.json').read_bytes()
|
|
|
|
|
|
def test_incomplete_component_manifest_fails_closed_instead_of_all_match(scope_case, monkeypatch):
|
|
preparer, project, rules, *_ = scope_case
|
|
monkeypatch.setattr(preparer, 'discover_project', lambda *args, **kwargs:
|
|
ProjectDiscovery((('MAIN', '1'),), {('MAIN', '1'): frozenset({'old'})}))
|
|
with pytest.raises(TaskCenterError) as error:
|
|
preparer.ensure_batch_handoff('t', (project,), rules)
|
|
assert error.value.code == 'component_scope'
|
|
assert not (preparer.data_root / 'quick-run/command.tsv').exists()
|
|
|
|
|
|
def test_missing_terminal_marker_never_dispatches_empty_target_selectors(scope_case):
|
|
preparer, project, rules, _, _, calls = scope_case
|
|
missing = RuleRecord('missing', 't', 0, 'ABSENT', 'DEST', True)
|
|
handoff = preparer.ensure_batch_handoff('t', (project,), (missing, *rules))
|
|
handoff.status_path.write_text('job_id\tstate\tcode\tmessage\n')
|
|
session = preparer.begin_batch_session('t', (project,), (missing, *rules))
|
|
with pytest.raises(TaskCenterError) as error:
|
|
preparer.execute_step('t', (project,), (missing, *rules), batch_mode=True, batch_session=session)
|
|
assert error.value.code == 'component_scope'
|
|
assert not calls
|
|
|
|
|
|
def test_empty_command_proof_requires_the_exact_full_frozen_queue(scope_case):
|
|
import json
|
|
from dx_productivity.trial_task_center.component_scope import validate_empty_command
|
|
preparer, project, rules, *_ = scope_case
|
|
missing = RuleRecord('missing', 't', 0, 'ABSENT', 'DEST', True)
|
|
handoff = preparer.ensure_batch_handoff('t', (project,), (missing, *rules))
|
|
empty = read_command_rows(handoff.command_path)[0]
|
|
assert validate_empty_command(handoff.command_path.parent, empty)
|
|
scope_path = handoff.command_path.with_name('component-scope.json')
|
|
scope = json.loads(scope_path.read_text())
|
|
scope['projects'][0]['components'].pop()
|
|
scope_path.write_text(json.dumps(scope))
|
|
assert not validate_empty_command(handoff.command_path.parent, empty)
|
|
|
|
|
|
def test_real_journal_keeps_empty_rule_manual_and_executes_other_exact_uids(scope_case, tmp_path, monkeypatch):
|
|
from threading import Event
|
|
from dx_productivity.trial_task_center.logging_setup import configure_logging
|
|
from dx_productivity.trial_task_center.service import TaskCenterService
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
from dx_productivity.trial_task_center.task_queue import execute_task_queue
|
|
preparer, project, _, _, _, calls = scope_case
|
|
store = TaskStore(tmp_path / 'tasks.db')
|
|
service = TaskCenterService(store, configure_logging(preparer.data_root), quick_run_preparer=preparer)
|
|
try:
|
|
task = service.create_project_tasks(project.path.parent)[0]
|
|
service.add_rule(task.task_id, 'ABSENT', 'DEST')
|
|
service.add_rule(task.task_id, 'OLD', 'NEW')
|
|
child = service.for_project_task(task.task_id)
|
|
monkeypatch.setattr(child._quick_run_preparer, 'discover_project', preparer.discover_project)
|
|
result = execute_task_queue(service, (task.task_id,), stop_event=Event())
|
|
assert not result.paused and result.entries[0].state == 'failed'
|
|
assert [row['target_selectors'] for row in calls] == ['uid-1\x1fR1\x1f10K', 'uid-2\x1fR2\x1f10K']
|
|
progress = service.quick_run_progress(task.task_id)
|
|
assert progress.queue_complete and progress.failed_items == 1 and progress.saved_items == 2
|
|
issues = service.execution_problems(task.task_id)
|
|
assert len(issues) == 1 and issues[0]['code'] == 'inventory_empty' and issues[0]['classification'] == 'manual'
|
|
assert service.reserve_problem_retry(task.task_id, source='dsh') == ()
|
|
execute_task_queue(service, (task.task_id,), stop_event=Event(), queue_id=result.queue_id)
|
|
assert len(calls) == 2
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_real_raw_retry_inherits_original_uids_and_does_not_repeat_success(scope_case, tmp_path, monkeypatch):
|
|
from threading import Event
|
|
from dx_productivity.trial_task_center.logging_setup import configure_logging
|
|
from dx_productivity.trial_task_center.service import TaskCenterService
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
from dx_productivity.trial_task_center.task_queue import execute_task_queue
|
|
preparer, project, _, _, _, calls = scope_case
|
|
original_worker = preparer._process_runner
|
|
failed = False
|
|
def worker(command, timeout):
|
|
nonlocal failed
|
|
root = Path(command[3])
|
|
row = read_command_rows(root / 'current-command.tsv')[0]
|
|
if row['target_selectors'].startswith('uid-1\x1f') and not failed:
|
|
failed = True
|
|
calls.append(row)
|
|
with (root / 'status.tsv').open('a', encoding='utf8') as stream:
|
|
stream.write(f'{command[-1]}\tbatch_failed\tcad_attachment_failed\tcontrolled prewrite failure\n')
|
|
return subprocess.CompletedProcess(command, 0, '', '')
|
|
return original_worker(command, timeout)
|
|
preparer._process_runner = worker
|
|
store = TaskStore(tmp_path / 'tasks.db')
|
|
service = TaskCenterService(store, configure_logging(preparer.data_root), quick_run_preparer=preparer)
|
|
try:
|
|
task = service.create_project_tasks(project.path.parent)[0]
|
|
service.add_rule(task.task_id, 'OLD', 'NEW')
|
|
child = service.for_project_task(task.task_id)
|
|
monkeypatch.setattr(child._quick_run_preparer, 'discover_project', preparer.discover_project)
|
|
result = execute_task_queue(service, (task.task_id,), stop_event=Event(), defer_problem_pass=True)
|
|
assert not result.paused and len(calls) == 2
|
|
original_scope = (child._quick_run_preparer.data_root / 'quick-run/component-scope.json').read_bytes()
|
|
monkeypatch.setattr(child._quick_run_preparer, 'discover_project', lambda *args, **kwargs: pytest.fail('Retry must inherit frozen inventory'))
|
|
reserved = service.reserve_problem_retry(task.task_id, source='dsh')
|
|
assert len(reserved) == 1
|
|
service.prepare_failed_quick_run(task.task_id, operation_keys=reserved)
|
|
assert (child._quick_run_preparer.data_root / 'quick-run/component-scope.json').read_bytes() == original_scope
|
|
retried = execute_task_queue(service, (task.task_id,), stop_event=Event())
|
|
assert not retried.paused and retried.entries[0].state == 'completed'
|
|
assert [row['target_selectors'].split('\x1f')[0] for row in calls] == ['uid-1', 'uid-2', 'uid-1']
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_retry_inherits_legacy_grouped_target_shape(scope_case):
|
|
preparer, project, _, components, *_ = scope_case
|
|
rules = (TargetRule('OLD', 'NEW', components),)
|
|
sheets = {_path_key(project.path): (('MAIN', '1'),)}
|
|
original = preparer.prepare('t', (project,), rules, sheet_targets=sheets, split_targets=False)
|
|
staged = preparer.for_data_root(preparer.data_root / 'retry-stage')
|
|
retried = staged.prepare('t', (project,), rules, sheet_targets=sheets, component_scope_from=original.command_path.parent)
|
|
assert read_command_rows(retried.command_path) == read_command_rows(original.command_path)
|
|
assert len(read_command_rows(retried.command_path)) == 1
|
|
|
|
|
|
def test_retry_missing_frozen_sidecar_cannot_become_an_all_match_queue(scope_case):
|
|
preparer, project, rules, *_ = scope_case
|
|
original = preparer.ensure_batch_handoff('t', (project,), rules)
|
|
original.command_path.with_name('component-scope.json').unlink()
|
|
staged = preparer.for_data_root(preparer.data_root / 'retry-stage')
|
|
with pytest.raises(TaskCenterError) as error:
|
|
staged.prepare('t', (project,), rules, sheet_targets={_path_key(project.path): (('MAIN', '1'),)},
|
|
component_scope_from=original.command_path.parent)
|
|
assert error.value.code == 'component_scope'
|
|
assert not (staged.data_root / 'quick-run/command.tsv').exists()
|