F-r-ldraledigplannerare/backend/tests/unit/test_services/test_allocation_input_loader.py

"""Tests for `AllocationInputLoader` — the only I/O-touching half of the
planning engine (see app.services.allocation_service module docstring).

Uses the same sqlite-backed fixtures as the rest of the service test suite
(tests/conftest.py) to seed a realistic workspace and verify the loader nets
out already-committed `planned_leave_day` rows, falls back to default
entitlement when no FK snapshot exists, and resolves the age-4 savable-days
cap from parent count.
"""

from datetime import date, datetime
from uuid import uuid4

import pytest

from app.entities.child import Child
from app.entities.day_override import DayOverride
from app.entities.leave_wish import LeaveWish
from app.entities.parental_leave import ParentalLeaveFetch, TierData
from app.entities.personal_data import PersonalData
from app.entities.planned_leave import PlannedLeaveDay
from app.entities.vacation_days import VacationDays
from app.entities.workspace import Workspace
from app.repositories_impl.sqlite.child_repository import SQLiteChildRepository
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.personal_data_repository import SQLitePersonalDataRepository
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 AllocationInputLoader, Allocator, PlanningEngineService
from app.utils.errors import NotFoundError, ValidationError


def _make_loader(
    workspace_repo: SQLiteWorkspaceRepository,
    child_repo: SQLiteChildRepository,
    personal_data_repo: SQLitePersonalDataRepository,
    parental_leave_repo: SQLiteParentalLeaveRepository,
    vacation_repo: SQLiteVacationDaysRepository,
    planned_leave_repo: SQLitePlannedLeaveRepository,
    leave_wish_repo: SQLiteLeaveWishRepository,
) -> AllocationInputLoader:
    return AllocationInputLoader(
        workspace_repo=workspace_repo,
        child_repo=child_repo,
        personal_data_repo=personal_data_repo,
        parental_leave_repo=parental_leave_repo,
        vacation_repo=vacation_repo,
        planned_leave_repo=planned_leave_repo,
        leave_wish_repo=leave_wish_repo,
    )


class TestAllocationInputLoader:
    async def test_workspace_not_found_raises(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
    ) -> None:
        loader = _make_loader(
            workspace_repo,
            child_repo,
            personal_data_repo,
            parental_leave_repo,
            vacation_repo,
            planned_leave_repo,
            leave_wish_repo,
        )
        with pytest.raises(NotFoundError):
            await loader.load(uuid4(), today=date(2027, 1, 1))

    async def test_load_nets_out_committed_days_and_defaults_entitlement(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
    ) -> None:
        now = datetime.now()
        ws = await workspace_repo.create(
            Workspace(
                id=uuid4(),
                name="Familj",
                created_at=now,
            )
        )
        parent_with_fetch = await personal_data_repo.create(
            PersonalData(
                uuid=uuid4(),
                workspace_id=ws.id,
                name="Parent1",
                salary_type="monthly",
                employment_status="employed",
                created_at=now,
            )
        )
        parent_without_fetch = await personal_data_repo.create(
            PersonalData(
                uuid=uuid4(),
                workspace_id=ws.id,
                name="Parent2",
                salary_type="hourly",
                employment_status="employed",
                created_at=now,
            )
        )
        child = await child_repo.create(
            Child(
                id=uuid4(),
                workspace_id=ws.id,
                name="Barn",
                birth_date=date(2026, 1, 1),
                created_at=now,
            )
        )

        tier = TierData(
            sjukpenning_total=390,
            sjukpenning_used=100,
            sjukpenning_left=290,
            lagsta_niva_total=90,
            lagsta_niva_used=0,
            lagsta_niva_left=90,
        )
        await parental_leave_repo.create(
            ParentalLeaveFetch(
                id=uuid4(),
                personal_data_uuid=parent_with_fetch.uuid,
                workspace_id=ws.id,
                child_id=child.id,
                source="manual",
                fetched_at=now,
                total_days=240,
                days_used=100,
                days_left=140,
                reserved_days_total=90,
                reserved_days_left=90,
                transferable_days_left=50,
                dubbeldagar_left=60,
                tier_data=tier,
                created_at=now,
                updated_at=now,
            )
        )

        # Two already-committed FP days for parent_with_fetch that the FK
        # snapshot above does not know about yet -> must be netted out.
        for i in range(2):
            await planned_leave_repo.create(
                PlannedLeaveDay(
                    id=uuid4(),
                    workspace_id=ws.id,
                    child_id=child.id,
                    parent_personal_data_uuid=parent_with_fetch.uuid,
                    date=date(2027, 3, 1 + i),
                    day_type="sjukpenning",
                )
            )
        # A committed vacation day for the same parent, in 2027.
        await planned_leave_repo.create(
            PlannedLeaveDay(
                id=uuid4(),
                workspace_id=ws.id,
                child_id=child.id,
                parent_personal_data_uuid=parent_with_fetch.uuid,
                date=date(2027, 4, 1),
                day_type="vacation",
            )
        )
        await vacation_repo.create(
            VacationDays(
                id=uuid4(),
                personal_data_uuid=parent_with_fetch.uuid,
                workspace_id=ws.id,
                year=2027,
                total_days=25,
                saved_days_in=0,
            )
        )

        loader = _make_loader(
            workspace_repo,
            child_repo,
            personal_data_repo,
            parental_leave_repo,
            vacation_repo,
            planned_leave_repo,
            leave_wish_repo,
        )
        alloc_input = await loader.load(ws.id, today=date(2027, 1, 1))

        assert alloc_input.today == date(2027, 1, 1)
        # Two parents -> per-parent age-4 cap (48), not the per-child figure (96).
        assert alloc_input.age4_savable_cap == 48

        pool_with_fetch = alloc_input.pools[(parent_with_fetch.uuid, child.id)]
        assert pool_with_fetch.sjukpenning_left == 288  # 290 - 2 committed
        assert pool_with_fetch.lagsta_left == 90

        # No FK snapshot at all for parent_without_fetch -> default entitlement.
        # `rules.sjukpenning_days`/`lagsta_niva_days` (390/90) are the WHOLE
        # CHILD's combined tier totals across both parents, so a single
        # parent's default share is half of each (195/45, summing to
        # `rules.days_per_parent` == 240) — matching AnalyticsService's own
        # no-snapshot fallback (Bug A regression: these two must agree).
        pool_defaulted = alloc_input.pools[(parent_without_fetch.uuid, child.id)]
        assert pool_defaulted.sjukpenning_left == 195
        assert pool_defaulted.lagsta_left == 45

        vac = alloc_input.vacation[(parent_with_fetch.uuid, 2027)]
        assert vac.total_days == 25
        assert vac.already_used == 1  # the committed vacation day

        assert len(alloc_input.existing_planned) == 3
        assert alloc_input.horizon_end >= date(2030, 1, 1)  # at least the child's 4th birthday
        assert date(2027, 6, 6) in alloc_input.holidays  # Sweden's national day

        # Task 1: PersonalData.min_vacation_days_per_year (default 20) must be
        # plumbed onto ParentFacts so the pure Allocator can enforce it without
        # touching a repository.
        parent_facts_by_uuid = {p.uuid: p for p in alloc_input.parents}
        assert parent_facts_by_uuid[parent_with_fetch.uuid].min_vacation_days_per_year == 20
        assert parent_facts_by_uuid[parent_without_fetch.uuid].min_vacation_days_per_year == 20

    async def test_only_pinned_existing_hides_unpinned_wish_rows_but_all_existing_planned_keeps_them(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
    ) -> None:
        """§fix (parent-reassignment moves dates, decision B) — `sync_plan`

        loads with `only_pinned_existing=True`, which must keep hiding
        unpinned wish-attributed rows from `existing_planned` (unchanged
        behaviour), but `all_existing_planned` must carry EVERY persisted
        row regardless — that's what lets `_Ledger._persisted_by_wish` find
        a flexible wish's own prior placement even when it's currently
        hidden from `existing_planned`. See `AllocationInput
        .all_existing_planned`'s docstring in allocation_service.py.
        """
        now = datetime.now()
        ws = await workspace_repo.create(Workspace(id=uuid4(), name="Familj", created_at=now))
        parent = await personal_data_repo.create(
            PersonalData(
                uuid=uuid4(),
                workspace_id=ws.id,
                name="Parent",
                salary_type="monthly",
                employment_status="employed",
                created_at=now,
            )
        )
        child = await child_repo.create(
            Child(
                id=uuid4(),
                workspace_id=ws.id,
                name="Barn",
                birth_date=date(2026, 1, 1),
                created_at=now,
            )
        )
        wish = await leave_wish_repo.create(
            LeaveWish(
                id=uuid4(),
                workspace_id=ws.id,
                child_id=child.id,
                name="Höstlov",
                window_start_month=10,
                window_start_day=1,
                window_end_month=10,
                window_end_day=7,
                target_weeks=1,
                recurrence="once",
                first_year=2027,
                last_year=None,
                priority=1,
                parent_mode="either",
                parent_personal_data_uuid=None,
                window_mode="flexible",
            )
        )

        pinned = await planned_leave_repo.create(
            PlannedLeaveDay(
                id=uuid4(),
                workspace_id=ws.id,
                child_id=child.id,
                parent_personal_data_uuid=parent.uuid,
                date=date(2027, 10, 1),
                day_type="vacation",
                is_pinned=True,
            )
        )
        unpinned_wish_row = await planned_leave_repo.create(
            PlannedLeaveDay(
                id=uuid4(),
                workspace_id=ws.id,
                child_id=child.id,
                parent_personal_data_uuid=parent.uuid,
                date=date(2027, 10, 4),
                day_type="vacation",
                wish_id=wish.id,
                is_pinned=False,
            )
        )
        ad_hoc = await planned_leave_repo.create(
            PlannedLeaveDay(
                id=uuid4(),
                workspace_id=ws.id,
                child_id=child.id,
                parent_personal_data_uuid=parent.uuid,
                date=date(2027, 10, 5),
                day_type="vacation",
                wish_id=None,
                is_pinned=False,
            )
        )

        loader = _make_loader(
            workspace_repo,
            child_repo,
            personal_data_repo,
            parental_leave_repo,
            vacation_repo,
            planned_leave_repo,
            leave_wish_repo,
        )
        alloc_input = await loader.load(ws.id, today=date(2027, 1, 1), only_pinned_existing=True)

        visible_ids = {d.id for d in alloc_input.existing_planned}
        assert visible_ids == {pinned.id, ad_hoc.id}
        assert unpinned_wish_row.id not in visible_ids

        assert alloc_input.all_existing_planned is not None
        all_ids = {d.id for d in alloc_input.all_existing_planned}
        assert all_ids == {pinned.id, unpinned_wish_row.id, ad_hoc.id}

    async def test_load_reflects_a_custom_minimum_vacation_days(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
    ) -> None:
        """A parent whose employer sets a higher-than-statutory floor (Task 1)
        must have that reflected on `ParentFacts`, not the seeded default."""
        now = datetime.now()
        ws = await workspace_repo.create(Workspace(id=uuid4(), name="Familj", created_at=now))
        parent = await personal_data_repo.create(
            PersonalData(
                uuid=uuid4(),
                workspace_id=ws.id,
                name="Parent",
                min_vacation_days_per_year=25,
                created_at=now,
            )
        )

        loader = _make_loader(
            workspace_repo,
            child_repo,
            personal_data_repo,
            parental_leave_repo,
            vacation_repo,
            planned_leave_repo,
            leave_wish_repo,
        )
        alloc_input = await loader.load(ws.id, today=date(2027, 1, 1))

        assert len(alloc_input.parents) == 1
        assert alloc_input.parents[0].uuid == parent.uuid
        assert alloc_input.parents[0].min_vacation_days_per_year == 25

    async def test_planning_engine_service_glues_loader_and_allocator(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
    ) -> None:
        now = datetime.now()
        ws = await workspace_repo.create(Workspace(id=uuid4(), name="Solo", created_at=now))
        await personal_data_repo.create(
            PersonalData(uuid=uuid4(), workspace_id=ws.id, name="Solo Parent", created_at=now)
        )

        loader = _make_loader(
            workspace_repo,
            child_repo,
            personal_data_repo,
            parental_leave_repo,
            vacation_repo,
            planned_leave_repo,
            leave_wish_repo,
        )
        service = PlanningEngineService(loader, Allocator())

        proposal = await service.propose(ws.id, today=date(2027, 1, 1))

        assert proposal.days == []
        assert proposal.outcomes == []

    async def test_day_overrides_default_to_empty_without_a_repo(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
    ) -> None:
        """`day_override_repo` is optional (backward compatible) — omitting it
        must not crash the loader, just leave `day_overrides` empty."""
        ws = await workspace_repo.create(
            Workspace(id=uuid4(), name="No overrides", created_at=datetime.now())
        )
        await personal_data_repo.create(
            PersonalData(uuid=uuid4(), workspace_id=ws.id, name="Parent", created_at=datetime.now())
        )
        loader = _make_loader(
            workspace_repo,
            child_repo,
            personal_data_repo,
            parental_leave_repo,
            vacation_repo,
            planned_leave_repo,
            leave_wish_repo,
        )

        alloc_input = await loader.load(ws.id, today=date(2027, 1, 1))

        assert alloc_input.day_overrides == {}

    async def test_day_overrides_loaded_from_repository(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
        day_override_repo: SQLiteDayOverrideRepository,
    ) -> None:
        """When a `DayOverrideRepository` is wired in, its rows land in
        `AllocationInput.day_overrides` as {date: is_working_day}."""
        now = datetime.now()
        ws = await workspace_repo.create(
            Workspace(id=uuid4(), name="With overrides", created_at=now)
        )
        await personal_data_repo.create(
            PersonalData(uuid=uuid4(), workspace_id=ws.id, name="Parent", created_at=now)
        )
        await day_override_repo.create(
            DayOverride(
                id=uuid4(),
                workspace_id=ws.id,
                date=date(2027, 12, 24),
                is_working_day=True,
                created_at=now,
                updated_at=now,
            )
        )
        await day_override_repo.create(
            DayOverride(
                id=uuid4(),
                workspace_id=ws.id,
                date=date(2027, 2, 2),
                is_working_day=False,
                created_at=now,
                updated_at=now,
            )
        )

        loader = AllocationInputLoader(
            workspace_repo=workspace_repo,
            child_repo=child_repo,
            personal_data_repo=personal_data_repo,
            parental_leave_repo=parental_leave_repo,
            vacation_repo=vacation_repo,
            planned_leave_repo=planned_leave_repo,
            leave_wish_repo=leave_wish_repo,
            day_override_repo=day_override_repo,
        )

        alloc_input = await loader.load(ws.id, today=date(2027, 1, 1))

        assert alloc_input.day_overrides == {
            date(2027, 12, 24): True,
            date(2027, 2, 2): False,
        }

    async def test_load_costs_julafton_correctly_for_a_far_future_horizon(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
    ) -> None:
        """Before the cache was extended to ~30 years, a horizon reaching the
        late 2040s ran past the old 10-year cache (2026-2035) and the loader
        silently fell back to the live `holidays` library, which reports
        Julafton/Nyårsafton/Midsommarafton as ordinary working days. A child
        born in 2044 pushes the horizon (their 4th birthday) to 2048 — assert
        the resulting `holidays` map still carries all three as real red
        days that far out, proving the extended cache (not a silent
        fallback) served it, and that the allocator would cost them
        correctly rather than charging a needless semesterdag."""
        now = datetime.now()
        ws = await workspace_repo.create(Workspace(id=uuid4(), name="Future", created_at=now))
        await personal_data_repo.create(
            PersonalData(uuid=uuid4(), workspace_id=ws.id, name="Parent", created_at=now)
        )
        await child_repo.create(
            Child(
                id=uuid4(),
                workspace_id=ws.id,
                name="Barn",
                birth_date=date(2044, 1, 1),
                created_at=now,
            )
        )

        loader = _make_loader(
            workspace_repo,
            child_repo,
            personal_data_repo,
            parental_leave_repo,
            vacation_repo,
            planned_leave_repo,
            leave_wish_repo,
        )
        alloc_input = await loader.load(ws.id, today=date(2027, 1, 1))

        assert alloc_input.horizon_end.year == 2048

        julafton = alloc_input.holidays.get(date(2048, 12, 24))
        assert julafton is not None and "julafton" in julafton.lower()

        nyarsafton = alloc_input.holidays.get(date(2048, 12, 31))
        assert nyarsafton is not None and "nyårsafton" in nyarsafton.lower()

        midsommarafton = [
            n for d, n in alloc_input.holidays.items() if "midsommarafton" in n.lower()
        ]
        assert midsommarafton, "Midsommarafton must still be a real free day in 2048"

    async def test_load_raises_validation_error_when_horizon_exceeds_the_cache(
        self,
        workspace_repo: SQLiteWorkspaceRepository,
        child_repo: SQLiteChildRepository,
        personal_data_repo: SQLitePersonalDataRepository,
        parental_leave_repo: SQLiteParentalLeaveRepository,
        vacation_repo: SQLiteVacationDaysRepository,
        planned_leave_repo: SQLitePlannedLeaveRepository,
        leave_wish_repo: SQLiteLeaveWishRepository,
    ) -> None:
        """A wish with a far-out `last_year` and no children yet (so there's
        no age-12 hard cap to save it) can still in principle push the
        horizon past even a ~30-year cache. Rather than silently falling
        back to the live `holidays` library (the original bug) or silently
        clamping the horizon (which would contradict the §6 decision to plan
        past B4 and show the squeeze), the loader must raise a
        `ValidationError` — the same domain error `CalendarService` uses for
        an out-of-range `start_year` — so the router can turn it into a 422
        the UI can explain."""
        now = datetime.now()
        ws = await workspace_repo.create(Workspace(id=uuid4(), name="FarFuture", created_at=now))
        await personal_data_repo.create(
            PersonalData(uuid=uuid4(), workspace_id=ws.id, name="Parent", created_at=now)
        )
        await leave_wish_repo.create(
            LeaveWish(
                id=uuid4(),
                workspace_id=ws.id,
                child_id=None,
                name="Sommar",
                window_start_month=6,
                window_start_day=1,
                window_end_month=6,
                window_end_day=30,
                target_weeks=4,
                recurrence="yearly",
                first_year=2027,
                last_year=2200,
                priority=1,
                parent_mode="either",
                parent_personal_data_uuid=None,
            )
        )

        loader = _make_loader(
            workspace_repo,
            child_repo,
            personal_data_repo,
            parental_leave_repo,
            vacation_repo,
            planned_leave_repo,
            leave_wish_repo,
        )

        with pytest.raises(ValidationError):
            await loader.load(ws.id, today=date(2027, 1, 1))