252 lines
9.7 KiB
Python
252 lines
9.7 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
|
|
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 QuickRunProgress
|
|
from dx_productivity.trial_task_center.service import TaskCenterService
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
|
|
|
|
FIXTURES = Path(__file__).parents[1] / "fixtures" / "trial_task_center"
|
|
|
|
|
|
def _service(tmp_path: Path, opened: list[Path] | None = None) -> TaskCenterService:
|
|
probe_source = tmp_path / "menu-probe.json"
|
|
probe_source.write_text("baseline", encoding="utf-8")
|
|
return TaskCenterService(
|
|
TaskStore(tmp_path / "task-center.db"),
|
|
configure_logging(tmp_path / "storage"),
|
|
path_opener=(opened.append if opened is not None else lambda _: None),
|
|
clock=lambda: datetime(2026, 9, 4, tzinfo=timezone.utc),
|
|
probe_source_resolver=lambda _task, _project: probe_source,
|
|
)
|
|
|
|
|
|
def _write_profile(name: str, destination: Path, project: Path) -> None:
|
|
profile = json.loads((FIXTURES / name).read_text(encoding="utf-8"))
|
|
profile["project"]["identity"] = str(project)
|
|
destination.write_text(json.dumps(profile), encoding="utf-8")
|
|
|
|
|
|
def test_task_crud_scan_and_selection_commands_keep_previous_operator_choice(tmp_path: Path) -> None:
|
|
"""Replacing service delegation with UI-local state would lose the durable selection."""
|
|
service = _service(tmp_path)
|
|
root = tmp_path / "projects"
|
|
root.mkdir()
|
|
first = root / "one.prj"
|
|
second = root / "two.prj"
|
|
first.touch()
|
|
second.touch()
|
|
|
|
task = service.create_task("Trial", note="first")
|
|
service.update_task(task.task_id, name="Renamed", note="updated")
|
|
scanned = service.scan_projects(task.task_id, root)
|
|
service.set_project_selected(scanned[0].project_id, True)
|
|
rescan = service.scan_projects(task.task_id, root)
|
|
selected = service.select_all_projects(task.task_id)
|
|
cleared = service.clear_project_selection(task.task_id)
|
|
|
|
assert service.get_task(task.task_id).name == "Renamed"
|
|
assert next(project for project in rescan if project.project_id == scanned[0].project_id).selected
|
|
assert all(project.selected for project in selected)
|
|
assert not any(project.selected for project in cleared)
|
|
|
|
|
|
def test_bulk_selection_has_constant_project_list_queries(tmp_path: Path, monkeypatch) -> None:
|
|
service = _service(tmp_path)
|
|
root = tmp_path / "projects"
|
|
root.mkdir()
|
|
for index in range(200):
|
|
(root / f"project-{index:04d}.prj").touch()
|
|
task = service.create_task("Bulk")
|
|
service.scan_projects(task.task_id, root)
|
|
calls = 0
|
|
original = service._store.list_projects
|
|
|
|
def counted(task_id: str):
|
|
nonlocal calls
|
|
calls += 1
|
|
return original(task_id)
|
|
|
|
monkeypatch.setattr(service._store, "list_projects", counted)
|
|
|
|
selected = service.select_all_projects(task.task_id)
|
|
select_calls = calls
|
|
calls = 0
|
|
cleared = service.clear_project_selection(task.task_id)
|
|
|
|
assert all(project.selected for project in selected)
|
|
assert not any(project.selected for project in cleared)
|
|
assert select_calls <= 4
|
|
assert calls <= 4
|
|
|
|
|
|
def test_repeated_completed_progress_skips_redundant_database_sync(tmp_path: Path, monkeypatch) -> None:
|
|
service = _service(tmp_path)
|
|
root = tmp_path / "projects"
|
|
root.mkdir()
|
|
project_path = root / "one.prj"
|
|
project_path.touch()
|
|
task = service.create_task("Progress")
|
|
project = service.scan_projects(task.task_id, root)[0]
|
|
service.set_project_selected(project.project_id, True)
|
|
progress = QuickRunProgress(
|
|
1,
|
|
1,
|
|
None,
|
|
None,
|
|
None,
|
|
(project_path,),
|
|
True,
|
|
project_summaries=((project_path, "quick_run_result:1:0:saved"),),
|
|
saved_items=1,
|
|
)
|
|
service._synchronize_quick_run_progress(task.task_id, progress=progress)
|
|
sync_calls = 0
|
|
original = service._store.record_quick_run_progress
|
|
|
|
def counted(*args, **kwargs):
|
|
nonlocal sync_calls
|
|
sync_calls += 1
|
|
return original(*args, **kwargs)
|
|
|
|
monkeypatch.setattr(service._store, "record_quick_run_progress", counted)
|
|
|
|
service._synchronize_quick_run_progress(task.task_id, progress=progress)
|
|
|
|
assert sync_calls == 0
|
|
|
|
|
|
def test_operation_log_records_distinct_completion_time(tmp_path: Path) -> None:
|
|
timestamps = iter((
|
|
datetime(2026, 9, 7, 10, 0, tzinfo=timezone.utc),
|
|
datetime(2026, 9, 7, 10, 0, 3, tzinfo=timezone.utc),
|
|
))
|
|
logging = configure_logging(tmp_path / "storage")
|
|
service = TaskCenterService(
|
|
TaskStore(tmp_path / "task-center.db"),
|
|
logging,
|
|
clock=lambda: next(timestamps),
|
|
)
|
|
|
|
service.tasks()
|
|
log = logging.application_log_path.read_text(encoding="utf-8")
|
|
|
|
assert "operation_start=list_tasks task_id= at=2026-09-07T10:00:00+00:00" in log
|
|
assert "operation_complete=list_tasks task_id= at=2026-09-07T10:00:03+00:00" in log
|
|
|
|
|
|
def test_task_delete_and_restore_delegate_to_durable_store(tmp_path: Path) -> None:
|
|
"""Keeping deletion only in UI state would lose the audit-preserving soft-delete contract."""
|
|
service = _service(tmp_path)
|
|
task = service.create_task("Trial")
|
|
|
|
deleted = service.delete_task(task.task_id)
|
|
restored = service.restore_task(task.task_id)
|
|
|
|
assert deleted.task_id == task.task_id
|
|
assert restored.task_id == task.task_id
|
|
assert service.tasks() == (restored,)
|
|
|
|
|
|
def test_rule_validation_errors_are_task_center_errors_with_stable_ids(tmp_path: Path) -> None:
|
|
"""Leaking parser errors would deny the UI a support identifier for invalid mappings."""
|
|
service = _service(tmp_path)
|
|
task = service.create_task("Trial")
|
|
service.add_rule(task.task_id, "OLD-1", "NEW-1")
|
|
|
|
with pytest.raises(TaskCenterError) as raised:
|
|
service.add_rule(task.task_id, "NEW-1", "OLD-2")
|
|
|
|
assert raised.value.code == "mapping_chain"
|
|
assert raised.value.error_id.startswith("DXT-")
|
|
|
|
|
|
def test_current_instruction_log_tailing_and_injected_evidence_opener(tmp_path: Path) -> None:
|
|
"""The UI must receive guidance and paths through the service without launching Explorer itself."""
|
|
opened: list[Path] = []
|
|
service = _service(tmp_path, opened)
|
|
task = service.create_task("Trial")
|
|
service.add_rule(task.task_id, "OLD-1", "NEW-1")
|
|
root = tmp_path / "projects"
|
|
root.mkdir()
|
|
project_path = root / "one.prj"
|
|
project_path.touch()
|
|
project = service.scan_projects(task.task_id, root)[0]
|
|
service.set_project_selected(project.project_id, True)
|
|
before = tmp_path / "before.json"
|
|
_write_profile("profile-before.json", before, project_path)
|
|
|
|
service.start_task(task.task_id, disposable_copy_confirmed=True)
|
|
service.capture_before(task.task_id, project.project_id, before)
|
|
instruction = service.current_instruction(task.task_id)
|
|
evidence_path = service.open_evidence(task.task_id, project.project_id)
|
|
log_lines = service.tail_log(task.task_id, limit=4)
|
|
|
|
assert instruction is not None
|
|
assert instruction.project_path == project_path
|
|
assert instruction.rules[0].old_part_number == "OLD-1"
|
|
assert evidence_path == opened[0]
|
|
assert any("capture_before" in line for line in log_lines)
|
|
|
|
|
|
def test_tail_log_does_not_amplify_the_application_log(tmp_path: Path) -> None:
|
|
service = _service(tmp_path)
|
|
task = service.create_task("Log polling")
|
|
application_log = service._logging.application_log_path
|
|
before = application_log.read_text(encoding="utf-8")
|
|
|
|
assert service.tail_log(task.task_id, limit=10) == ()
|
|
|
|
assert application_log.read_text(encoding="utf-8") == before
|
|
|
|
|
|
def test_service_rejects_mapping_edits_while_an_attempt_is_active(tmp_path: Path) -> None:
|
|
"""Changing rules mid-attempt would make UI mappings disagree with captured evidence."""
|
|
service = _service(tmp_path)
|
|
task = service.create_task("Trial")
|
|
rule = service.add_rule(task.task_id, "OLD-1", "NEW-1")
|
|
root = tmp_path / "projects"
|
|
root.mkdir()
|
|
project_path = root / "one.prj"
|
|
project_path.touch()
|
|
project = service.scan_projects(task.task_id, root)[0]
|
|
service.set_project_selected(project.project_id, True)
|
|
|
|
service.start_task(task.task_id, disposable_copy_confirmed=True)
|
|
with pytest.raises(TaskCenterError) as raised:
|
|
service.update_rule(rule.rule_id, old_part_number="OLD-1", new_part_number="OTHER-1", enabled=True)
|
|
|
|
assert raised.value.code == "rules_locked"
|
|
with pytest.raises(TaskCenterError, match="rules_locked"):
|
|
service.add_rule(task.task_id, "OLD-2", "NEW-2")
|
|
with pytest.raises(TaskCenterError, match="rules_locked"):
|
|
service.delete_rule(rule.rule_id)
|
|
with pytest.raises(TaskCenterError, match="rules_locked"):
|
|
service.move_rule(rule.rule_id, 1)
|
|
|
|
|
|
def test_prepared_queue_freezes_project_inventory_and_rule_options(tmp_path: Path) -> None:
|
|
service = _service(tmp_path)
|
|
task = service.create_task("Frozen queue")
|
|
root = tmp_path / "projects"
|
|
root.mkdir()
|
|
(root / "one.prj").touch()
|
|
project = service.scan_projects(task.task_id, root)[0]
|
|
service.set_project_selected(project.project_id, True)
|
|
rule = service.add_rule(task.task_id, "OLD", "NEW")
|
|
service.prepare_quick_run(task.task_id)
|
|
|
|
with pytest.raises(TaskCenterError, match="quick_run_options_locked"):
|
|
service.set_project_selected(project.project_id, False)
|
|
with pytest.raises(TaskCenterError, match="quick_run_options_locked"):
|
|
service.scan_projects(task.task_id, root)
|
|
with pytest.raises(TaskCenterError, match="rules_locked"):
|
|
service.update_rule(rule.rule_id, old_part_number="OLD", new_part_number="OTHER", enabled=True)
|