Free days, vacation forfeiture, and global auto-replanning

Free days (Sat/Sun/red days, subject to DayOverride) can never be vacation, and can only be parental leave when the workspace opts in via take_pl_on_red_days. The allocator already honoured this; the hand-pin path bypassed it entirely. - PlanningService gains optional workspace_repo/day_override_repo deps and _reject_illegal_free_day, enforced in add_planned_day and update. Reuses allocation_service.is_free_day rather than re-deriving it, and no-ops when the deps are unset so existing callers are unaffected. - update_planned_day had no ValidationError handler at all, so a validation failure there 500'd instead of 422'ing. Fixed. - Calendar filters the pin write loop by the day's isFree; the modal explains free days stay off, and that pinning opts a day out of automatic re-planning. Vacation days at risk of forfeiture were computed and sent over the wire but never rendered: an at-risk column with the age-out/over-cap split, and a dashboard key figure. PlanProposal.warnings was likewise parsed but rendered nowhere, for all three kinds. Adds PlanWarningCard in a Risks section above the tips, with parent names resolved and dates formatted. POST /api/plan/sync now fires from the workspace layer on every plan-input change rather than only from Calendar, so a Settings edit or a pinned-day save re-plans day types instead of merely refetching. Overlapping bumps coalesce into one trailing run; a rejection cannot wedge the in-flight guard. eviction_preview was silently dropped by the frontend despite always being on the wire, and is now surfaced through context. Verified: backend 890 passed (91.49% coverage), frontend 1297 passed, ruff/eslint/tsc clean. Browser-checked in Swedish and English. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JVQx4NUvPbJhn6UcvRd2QY
2026-09-20 13:07:36 +02:00
parent 16390fec50
commit 61e5487078
44 changed files with 1891 additions and 60 deletions
@@ -0,0 +1,302 @@
+"""Tests for `PlanningService`'s free-day guard (hand-pin path).
+
+A free day (Saturday, Sunday, or Swedish red day, subject to a workspace
+`DayOverride`) can never be persisted as `vacation`; it may only be
+`sjukpenning`/`lagsta` when the workspace opted in via
+`Workspace.take_pl_on_red_days` (default False). See
+`PlanningService._reject_illegal_free_day` — the authoritative backend guard
+behind the calendar's hand-pin path (Calendar.tsx filters client-side too,
+but this is what actually protects the data).
+
+The guard is a no-op when the service is constructed without its two new
+optional deps (`workspace_repo`/`day_override_repo`) — existing direct-
+construction call sites (scripts/seed_demo.py, the plain `planning_service`
+fixture used by every other test in this suite) must keep today's behavior
+byte-identical.
+"""
+
+from datetime import date, datetime
+from uuid import uuid4
+
+import pytest
+import pytest_asyncio
+
+from app.entities.planned_leave import PlannedLeaveDay
+from app.entities.workspace import Workspace
+from app.repositories_impl.sqlite.day_override_repository import SQLiteDayOverrideRepository
+from app.repositories_impl.sqlite.leave_wish_repository import SQLiteLeaveWishRepository
+from app.repositories_impl.sqlite.parental_leave_repository import SQLiteParentalLeaveRepository
+from app.repositories_impl.sqlite.planned_leave_repository import SQLitePlannedLeaveRepository
+from app.repositories_impl.sqlite.vacation_days_repository import SQLiteVacationDaysRepository
+from app.repositories_impl.sqlite.workspace_repository import SQLiteWorkspaceRepository
+from app.services.allocation_service import PlanningEngineService
+from app.services.analytics_service import AnalyticsService
+from app.services.planning_service import PlanningService
+from app.utils.errors import ValidationError
+from tests.conftest import SeededIds
+
+# A plain Saturday with no coinciding public holiday.
+_SATURDAY = date(2026, 6, 13)
+# Juldagen (Christmas Day) 2026 — a Friday, so this exercises the "real red
+# day" branch of `is_free_day`, not just the weekend one.
+_RED_DAY = date(2026, 12, 25)
+# An ordinary Tuesday — never free.
+_WEEKDAY = date(2026, 6, 16)
+
+
+@pytest_asyncio.fixture
+async def guarded_planning_service(
+    planned_leave_repo: SQLitePlannedLeaveRepository,
+    analytics_service: AnalyticsService,
+    parental_leave_repo: SQLiteParentalLeaveRepository,
+    vacation_repo: SQLiteVacationDaysRepository,
+    planning_engine_service: PlanningEngineService,
+    leave_wish_repo: SQLiteLeaveWishRepository,
+    workspace_repo: SQLiteWorkspaceRepository,
+    day_override_repo: SQLiteDayOverrideRepository,
+) -> PlanningService:
+    """A `PlanningService` with the free-day guard's deps wired — mirrors
+
+    `app.dependencies.get_planning_service`, unlike the plain
+    `planning_service` fixture (which deliberately leaves them unset; see
+    `TestFreeDayGuardNoOp` below).
+    """
+    return PlanningService(
+        planned_leave_repo,
+        analytics_service,
+        parental_leave_repo,
+        vacation_repo,
+        planning_engine_service,
+        leave_wish_repo=leave_wish_repo,
+        workspace_repo=workspace_repo,
+        day_override_repo=day_override_repo,
+    )
+
+
+async def _set_take_pl_on_red_days(
+    workspace_repo: SQLiteWorkspaceRepository, workspace: Workspace, value: bool
+) -> None:
+    workspace.take_pl_on_red_days = value
+    await workspace_repo.update(workspace.id, workspace)
+
+
+class TestAddPlannedDayFreeDayGuard:
+    async def test_rejects_vacation_on_saturday(
+        self, guarded_planning_service: PlanningService, seeded_ids: SeededIds
+    ) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            await guarded_planning_service.add_planned_day(
+                workspace_id=seeded_ids.workspace_id,
+                child_id=seeded_ids.child_id,
+                parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+                date=_SATURDAY,
+                day_type="vacation",
+            )
+        assert exc_info.value.message_key == "planning.rejection.vacationOnFreeDay"
+
+    async def test_rejects_vacation_on_red_day(
+        self, guarded_planning_service: PlanningService, seeded_ids: SeededIds
+    ) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            await guarded_planning_service.add_planned_day(
+                workspace_id=seeded_ids.workspace_id,
+                child_id=seeded_ids.child_id,
+                parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+                date=_RED_DAY,
+                day_type="vacation",
+            )
+        assert exc_info.value.message_key == "planning.rejection.vacationOnFreeDay"
+
+    async def test_accepts_vacation_on_a_weekday(
+        self, guarded_planning_service: PlanningService, seeded_ids: SeededIds
+    ) -> None:
+        result = await guarded_planning_service.add_planned_day(
+            workspace_id=seeded_ids.workspace_id,
+            child_id=seeded_ids.child_id,
+            parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+            date=_WEEKDAY,
+            day_type="vacation",
+        )
+        assert result.day_type == "vacation"
+
+    async def test_rejects_sjukpenning_on_free_day_when_flag_off(
+        self, guarded_planning_service: PlanningService, seeded_ids: SeededIds
+    ) -> None:
+        with pytest.raises(ValidationError) as exc_info:
+            await guarded_planning_service.add_planned_day(
+                workspace_id=seeded_ids.workspace_id,
+                child_id=seeded_ids.child_id,
+                parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+                date=_SATURDAY,
+                day_type="sjukpenning",
+            )
+        assert exc_info.value.message_key == "planning.rejection.parentalLeaveOnFreeDayDisabled"
+
+    async def test_accepts_sjukpenning_on_free_day_when_flag_on(
+        self,
+        guarded_planning_service: PlanningService,
+        seeded_ids: SeededIds,
+        workspace_repo: SQLiteWorkspaceRepository,
+    ) -> None:
+        workspace = await workspace_repo.get_by_id(seeded_ids.workspace_id)
+        assert workspace is not None
+        await _set_take_pl_on_red_days(workspace_repo, workspace, True)
+
+        result = await guarded_planning_service.add_planned_day(
+            workspace_id=seeded_ids.workspace_id,
+            child_id=seeded_ids.child_id,
+            parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+            date=_SATURDAY,
+            day_type="sjukpenning",
+        )
+        assert result.day_type == "sjukpenning"
+
+    async def test_accepts_lagsta_on_free_day_when_flag_on(
+        self,
+        guarded_planning_service: PlanningService,
+        seeded_ids: SeededIds,
+        workspace_repo: SQLiteWorkspaceRepository,
+    ) -> None:
+        workspace = await workspace_repo.get_by_id(seeded_ids.workspace_id)
+        assert workspace is not None
+        await _set_take_pl_on_red_days(workspace_repo, workspace, True)
+
+        result = await guarded_planning_service.add_planned_day(
+            workspace_id=seeded_ids.workspace_id,
+            child_id=seeded_ids.child_id,
+            parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+            date=_RED_DAY,
+            day_type="lagsta",
+        )
+        assert result.day_type == "lagsta"
+
+
+async def _create_row_directly(
+    planned_leave_repo: SQLitePlannedLeaveRepository,
+    seeded_ids: SeededIds,
+    day: date,
+    day_type: str,
+) -> PlannedLeaveDay:
+    """Seed a `planned_leave_day` row straight through the repository,
+
+    bypassing `PlanningService.add_planned_day` — used where the row's
+    starting state (a free-day date already holding a PL type) could only
+    ever have been reached with `take_pl_on_red_days` on, but the test wants
+    to exercise `update`'s guard independent of that flag's current value.
+    """
+    now = datetime.now()
+    return await planned_leave_repo.create(
+        PlannedLeaveDay(
+            id=uuid4(),
+            workspace_id=seeded_ids.workspace_id,
+            child_id=seeded_ids.child_id,
+            parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+            date=day,
+            day_type=day_type,
+            created_at=now,
+            updated_at=now,
+        )
+    )
+
+
+class TestUpdateFreeDayGuard:
+    async def test_rejects_retyping_to_vacation_on_saturday(
+        self,
+        guarded_planning_service: PlanningService,
+        seeded_ids: SeededIds,
+        planned_leave_repo: SQLitePlannedLeaveRepository,
+    ) -> None:
+        row = await _create_row_directly(planned_leave_repo, seeded_ids, _SATURDAY, "sjukpenning")
+        with pytest.raises(ValidationError) as exc_info:
+            await guarded_planning_service.update(row.id, day_type="vacation")
+        assert exc_info.value.message_key == "planning.rejection.vacationOnFreeDay"
+
+    async def test_rejects_retyping_to_vacation_on_red_day(
+        self,
+        guarded_planning_service: PlanningService,
+        seeded_ids: SeededIds,
+        planned_leave_repo: SQLitePlannedLeaveRepository,
+    ) -> None:
+        row = await _create_row_directly(planned_leave_repo, seeded_ids, _RED_DAY, "lagsta")
+        with pytest.raises(ValidationError) as exc_info:
+            await guarded_planning_service.update(row.id, day_type="vacation")
+        assert exc_info.value.message_key == "planning.rejection.vacationOnFreeDay"
+
+    async def test_rejects_sjukpenning_on_free_day_when_flag_off(
+        self,
+        guarded_planning_service: PlanningService,
+        seeded_ids: SeededIds,
+        planned_leave_repo: SQLitePlannedLeaveRepository,
+    ) -> None:
+        # Starts as `lagsta` (only reachable with the flag on, but the flag
+        # is off for this test — see `_create_row_directly`'s docstring) so
+        # retyping to `sjukpenning` exercises only `update`'s own guard,
+        # checked against the row's own (free) date.
+        row = await _create_row_directly(planned_leave_repo, seeded_ids, _SATURDAY, "lagsta")
+        with pytest.raises(ValidationError) as exc_info:
+            await guarded_planning_service.update(row.id, day_type="sjukpenning")
+        assert exc_info.value.message_key == "planning.rejection.parentalLeaveOnFreeDayDisabled"
+
+    async def test_accepts_sjukpenning_on_free_day_when_flag_on(
+        self,
+        guarded_planning_service: PlanningService,
+        seeded_ids: SeededIds,
+        planned_leave_repo: SQLitePlannedLeaveRepository,
+        workspace_repo: SQLiteWorkspaceRepository,
+    ) -> None:
+        workspace = await workspace_repo.get_by_id(seeded_ids.workspace_id)
+        assert workspace is not None
+        await _set_take_pl_on_red_days(workspace_repo, workspace, True)
+
+        row = await _create_row_directly(planned_leave_repo, seeded_ids, _SATURDAY, "lagsta")
+        updated = await guarded_planning_service.update(row.id, day_type="sjukpenning")
+        assert updated.day_type == "sjukpenning"
+
+    async def test_update_of_an_unrelated_field_still_checks_day_type_when_given(
+        self,
+        guarded_planning_service: PlanningService,
+        seeded_ids: SeededIds,
+        planned_leave_repo: SQLitePlannedLeaveRepository,
+    ) -> None:
+        """Passing `is_pinned` alongside an illegal `day_type` must still
+
+        reject — the guard runs whenever `day_type` is part of the call,
+        regardless of what else is being updated in the same call.
+        """
+        row = await _create_row_directly(planned_leave_repo, seeded_ids, _SATURDAY, "lagsta")
+        with pytest.raises(ValidationError):
+            await guarded_planning_service.update(row.id, day_type="vacation", is_pinned=True)
+
+
+class TestFreeDayGuardNoOp:
+    """Behaviour must be byte-identical for callers that don't wire the new
+
+    deps — `scripts/seed_demo.py`, and every other test in this suite that
+    uses the plain `planning_service` fixture.
+    """
+
+    async def test_add_planned_day_allows_vacation_on_saturday_without_deps(
+        self, planning_service: PlanningService, seeded_ids: SeededIds
+    ) -> None:
+        result = await planning_service.add_planned_day(
+            workspace_id=seeded_ids.workspace_id,
+            child_id=seeded_ids.child_id,
+            parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+            date=_SATURDAY,
+            day_type="vacation",
+        )
+        assert result.day_type == "vacation"
+        assert result.date == _SATURDAY
+
+    async def test_update_allows_retyping_to_vacation_on_saturday_without_deps(
+        self, planning_service: PlanningService, seeded_ids: SeededIds
+    ) -> None:
+        row = await planning_service.add_planned_day(
+            workspace_id=seeded_ids.workspace_id,
+            child_id=seeded_ids.child_id,
+            parent_personal_data_uuid=seeded_ids.personal_data_uuid,
+            date=_SATURDAY,
+            day_type="sjukpenning",
+        )
+        updated = await planning_service.update(row.id, day_type="vacation")
+        assert updated.day_type == "vacation"