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)