F-r-ldraledigplannerare/backend/tests/unit/test_planning_service_free_days.py

"""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.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,
    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,
        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 another field 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_dubbeldag=False)


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"