160 lines
7.5 KiB
Python
160 lines
7.5 KiB
Python
from dataclasses import replace
|
|
import json
|
|
|
|
import pytest
|
|
|
|
from dx_productivity.dsh.impact import execution_impact
|
|
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.service import TaskCenterService
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow
|
|
from dx_productivity.trial_task_center.task_queue import _plan_hash
|
|
|
|
|
|
@pytest.fixture
|
|
def setup(tmp_path):
|
|
store = TaskStore(tmp_path / 'tasks.db')
|
|
service = TaskCenterService(store, configure_logging(tmp_path / 'data'))
|
|
paths = []
|
|
for name in ('exact', 'mapping'):
|
|
path = tmp_path / name / 'board.prj'
|
|
path.parent.mkdir()
|
|
path.write_text('project fixture', encoding='utf-8')
|
|
paths.append(path)
|
|
tasks = []
|
|
for index, path in enumerate(paths):
|
|
task = store.create_task(path.parent.name)
|
|
project = store.sync_projects(task.task_id, path.parent, (path,))[0]
|
|
store.set_project_selected(project.project_id, True)
|
|
tasks.append(store.bind_project_task(task.task_id, project.project_id, f'g{index}', 0))
|
|
targets = tuple(ComponentTarget(paths[0], 'MAIN', '1', f'u{i}', f'R{i}', 'OLD', f'V{i}') for i in range(1, 4))
|
|
store.record_target_inventory(tasks[0].task_id, targets)
|
|
rows = (TargetPlanRow(targets[0], True, 'NEW', target_cell='CELL-X'),
|
|
TargetPlanRow(targets[1], True, 'NEW', True, 'CUSTOM', False),
|
|
TargetPlanRow(targets[2], False, 'NEW2'))
|
|
store.replace_target_plan(tasks[0].task_id, rows)
|
|
store.add_rule(tasks[1].task_id, 'M-OLD', 'M-NEW', target_cell='CELL-M')
|
|
store.add_rule(tasks[1].task_id, 'OFF', 'OFF-NEW', enabled=False)
|
|
store.set_copy_part_number_to_value(tasks[1].task_id, True)
|
|
yield service, store, tasks, paths
|
|
store.close()
|
|
|
|
|
|
def test_exact_target_plan_reports_saved_identities_policies_and_enabled_count(setup):
|
|
service, store, tasks, paths = setup
|
|
task_id = tasks[0].task_id
|
|
before = store._connection.total_changes
|
|
project_before = paths[0].read_bytes()
|
|
result = execution_impact(service, [task_id])
|
|
assert result['coverage'] == 'exact'
|
|
assert result['component_count'] == result['known_component_count'] == 2
|
|
assert result['enabled_scope'] == 2
|
|
assert result['total_rows'] == result['returned_rows'] == 3
|
|
first, custom, disabled = result['rows']
|
|
assert (first['sheet'], first['schematic_name'], first['refdes'], first['uid']) == ('1', 'MAIN', 'R1', 'u1')
|
|
assert first['project'].casefold() == str(paths[0]).casefold()
|
|
assert (first['old_part_number'], first['new_part_number']) == ('OLD', 'NEW')
|
|
assert first['old_value'] == 'V1'
|
|
assert first['value_policy'] == 'preserve'
|
|
assert first['proposed_value'] == 'V1'
|
|
assert first['target_cell'] == first['target_cell_policy'] == 'CELL-X'
|
|
assert first['nc_policy'] == 'sync'
|
|
assert custom['value_policy'] == 'custom' and custom['proposed_value'] == 'CUSTOM'
|
|
assert custom['nc_policy'] == 'preserve'
|
|
assert disabled['enabled'] is False and disabled['component_count'] == 0
|
|
assert result['plan_hashes'][task_id] == _plan_hash(service.for_project_task(task_id), task_id)
|
|
assert result['cad_connection_checked'] is False
|
|
assert store._connection.total_changes == before
|
|
assert paths[0].read_bytes() == project_before
|
|
json.dumps(result)
|
|
|
|
|
|
def test_mapping_mode_never_invents_component_count_or_matches(setup):
|
|
service, _, tasks, _ = setup
|
|
result = execution_impact(service, [tasks[1].task_id])
|
|
assert result['coverage'] == 'mapping_only'
|
|
assert result['component_count'] is None
|
|
assert result['known_component_count'] == 0
|
|
assert result['enabled_scope'] == 1
|
|
assert result['total_rows'] == 2
|
|
row = result['rows'][0]
|
|
assert row['component_count'] is None
|
|
assert row['mapping_scope'] == {'old_part_number': 'M-OLD', 'new_part_number': 'M-NEW'}
|
|
assert row['value_policy'] == 'part_label'
|
|
assert row['old_value'] is row['proposed_value'] is None
|
|
assert row['uid'] is row['refdes'] is row['sheet'] is None
|
|
assert row['target_cell_policy'] == 'CELL-M'
|
|
|
|
|
|
def test_copy_label_target_value_is_unknown_and_custom_override_stays_known(setup):
|
|
service, store, tasks, _ = setup
|
|
store.set_copy_part_number_to_value(tasks[0].task_id, True)
|
|
result = execution_impact(service, [tasks[0].task_id])
|
|
assert result['rows'][0]['value_policy'] == 'part_label'
|
|
assert result['rows'][0]['proposed_value'] is None
|
|
assert result['rows'][1]['value_policy'] == 'custom'
|
|
assert result['rows'][1]['proposed_value'] == 'CUSTOM'
|
|
|
|
|
|
def test_limit_applies_globally_but_hash_and_totals_cover_omitted_scope(setup):
|
|
service, store, tasks, _ = setup
|
|
ids = [task.task_id for task in tasks]
|
|
report = execution_impact(service, ids, limit=1)
|
|
assert report['coverage'] == 'mixed' and report['component_count'] is None
|
|
assert report['known_component_count'] == 2
|
|
assert report['enabled_scope'] == 3
|
|
assert report['truncated'] is True
|
|
assert report['total_rows'] == 5 and report['returned_rows'] == 1
|
|
assert report['omitted_row_count'] == 4
|
|
assert report['tasks'][1]['returned_rows'] == 0
|
|
assert report['tasks'][1]['omitted_row_count'] == 2
|
|
assert report['full_fingerprint'] == execution_impact(service, ids)['full_fingerprint']
|
|
assert report['fingerprint'] == execution_impact(service, ids)['fingerprint']
|
|
rows = store.list_target_plan(ids[0])
|
|
store.replace_target_plan(ids[0], rows[:2] + (replace(rows[2], new_part_number='CHANGED'),))
|
|
changed = execution_impact(service, ids, limit=1)
|
|
assert changed['rows'] == report['rows']
|
|
assert changed['full_fingerprint'] != report['full_fingerprint']
|
|
assert changed['plan_hashes'] != report['plan_hashes']
|
|
|
|
|
|
def test_empty_saved_target_plan_is_exact_zero_without_mapping_fallback(setup):
|
|
service, store, tasks, _ = setup
|
|
task_id = tasks[1].task_id
|
|
store.record_target_inventory(task_id, ())
|
|
result = execution_impact(service, [task_id])
|
|
assert result['coverage'] == 'exact'
|
|
assert result['component_count'] == 0 and result['rows'] == []
|
|
|
|
|
|
@pytest.mark.parametrize('task_ids', [(), [], 't1', ['t1', 't1'], [['x']], [None], [''], ['x' * 129], ['x'] * 21])
|
|
def test_invalid_scope_is_rejected_before_service_access(task_ids):
|
|
with pytest.raises(TaskCenterError) as caught:
|
|
execution_impact(object(), task_ids)
|
|
assert caught.value.code == 'assistant_task_scope'
|
|
|
|
|
|
@pytest.mark.parametrize('limit', [0, -1, True, 1.1, '1', 101, None])
|
|
def test_limit_is_strict_and_bounded_before_service_access(limit):
|
|
with pytest.raises(TaskCenterError) as caught:
|
|
execution_impact(object(), ['t1'], limit=limit)
|
|
assert caught.value.code == 'assistant_impact_limit'
|
|
|
|
|
|
def test_valid_unknown_task_id_retains_service_not_found_error(setup):
|
|
service, _, _, _ = setup
|
|
with pytest.raises(TaskCenterError) as caught:
|
|
execution_impact(service, ['missing'])
|
|
assert caught.value.code == 'unknown_task'
|
|
|
|
|
|
def test_saved_plan_hash_errors_are_not_replaced_with_synthetic_hashes(setup, monkeypatch):
|
|
service, _, tasks, _ = setup
|
|
def fail(_task_id):
|
|
raise TaskCenterError('controlled_read_error', 'cannot read frozen plan')
|
|
monkeypatch.setattr(service, 'for_project_task', fail)
|
|
with pytest.raises(TaskCenterError) as caught:
|
|
execution_impact(service, [tasks[0].task_id])
|
|
assert caught.value.code == 'controlled_read_error'
|