Let a day removed from a period stay removed

Taking one day out of a period the planner placed did nothing that
lasted: the period still asked for a full week, so the next sync put the
day straight back. The option was disabled rather than lying about it.

A removed day is now recorded as its own thing — no leave for this
parent, this child, this date — and the planner honours it on every
later sync. It is kept apart from the working-day overrides, which
answer a different question about the calendar rather than about the
plan.

The day belongs to the parent whose band was clicked, so removing one
parent's day leaves their partner's alone; where both parents were to be
off on one funding arrangement, the partner is simply funded on their
own instead. A removed day shortens what the period is asking for rather
than counting as a day the plan failed to find, so the advice about
closing a shortfall does not start arguing for a day nobody wants.

Nothing is removed without a way back: the toast undoes it, and the day
itself is marked in the calendar and offers to restore.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ei7gCZzdd751uZtPzb1Pep

backend/tests/unit/test_services/test_allocation_excluded_days.py

@@ -0,0 +1,270 @@
+"""The allocator must never re-place a day the user removed by hand.
+
+User's requirement, verbatim: "removing a single day should stay permanent.
+Even if it's an auto added period day." The wish still says "a full week", so
+without `AllocationInput.excluded_days` the next `POST /api/plan/sync` simply
+re-derives the removed date — which is exactly what these tests pin down.
+
+Two decisions are asserted here, both explained at length on
+`_Ledger._excluded_window_dates`:
+
+1. **The parent is part of the key.** A both-parents window places one day
+   per parent on the same date; removing one parent's day leaves the
+   partner's standing. A date only leaves the window entirely when no
+   responsible parent may take it.
+2. **An excluded date shrinks the window's target; it is not a shortfall.**
+   A day the user removed is not a day the plan failed to fund, so
+   `shortfall_days` must not grow (which would make the new shortfall
+   remedies advise freeing resources for a day nobody wants, and would make
+   `sync_plan`'s eviction preview treat a deliberate removal as a lost
+   priority race).
+"""
+
+from datetime import date
+
+from app.services.allocation_service import Allocator, DayPool, VacationBudget
+from tests.unit.test_services.test_allocation_service import _build_input, _child, _parent, _wish
+
+# Feb 2027 is the suite's clean "no red-day interference" month; Feb 1-7 2027
+# is Mon-Sun, so 5 spendable days + Sat 6 + Sun 7.
+_WINDOW_START = (2, 1)
+_WINDOW_END = (2, 7)
+_REMOVED = date(2027, 2, 3)  # a Wednesday in the middle of the window
+
+
+def _solo_scenario(*, excluded: frozenset | None = None, reuse=None):
+    """A one-parent, one-week fixed window.
+
+    `reuse` takes a `(child, parent)` pair from an earlier call so a test can
+    build two inputs that are identical down to the uuids — needed both for a
+    before/after comparison and for the determinism check, since `_Ledger`
+    mutates its copies of the pool/vacation dicts in place and every
+    `propose()` run therefore needs its own fresh input.
+    """
+    if reuse is not None:
+        child, parent = reuse
+    else:
+        child, parent = _child(birth_date=date(2025, 6, 1)), _parent(name="Solo")
+    wish = _wish(
+        child_id=child.id,
+        name="Sportlov",
+        start=_WINDOW_START,
+        end=_WINDOW_END,
+        weeks=1,
+        first_year=2027,
+        parent_mode="specific",
+        parent_uuid=parent.uuid,
+    )
+    alloc_input = _build_input(
+        today=date(2027, 1, 1),
+        horizon_end=date(2027, 12, 31),
+        children=[child],
+        parents=[parent],
+        pools={(parent.uuid, child.id): DayPool(200, 90, 60)},
+        vacation={(parent.uuid, 2027): VacationBudget(25, 0, 0)},
+        wishes=[wish],
+        excluded_days=excluded,
+    )
+    return alloc_input, parent, child
+
+
+def _both_scenario(*, excluded: frozenset | None = None, reuse=None):
+    """A both-parents ("co-leave") one-week fixed window; `reuse` as above."""
+    if reuse is not None:
+        child, parent_a, parent_b = reuse
+    else:
+        child = _child(birth_date=date(2025, 6, 1))
+        parent_a = _parent(name="A")
+        parent_b = _parent(name="B")
+    wish = _wish(
+        child_id=child.id,
+        name="Tillsammans",
+        start=_WINDOW_START,
+        end=_WINDOW_END,
+        weeks=1,
+        first_year=2027,
+        parent_mode="both",
+    )
+    alloc_input = _build_input(
+        today=date(2027, 1, 1),
+        horizon_end=date(2027, 12, 31),
+        children=[child],
+        parents=[parent_a, parent_b],
+        pools={
+            (parent_a.uuid, child.id): DayPool(200, 90, 60),
+            (parent_b.uuid, child.id): DayPool(200, 90, 60),
+        },
+        vacation={
+            (parent_a.uuid, 2027): VacationBudget(25, 0, 0),
+            (parent_b.uuid, 2027): VacationBudget(25, 0, 0),
+        },
+        wishes=[wish],
+        excluded_days=excluded,
+    )
+    return alloc_input, parent_a, parent_b, child
+
+
+class TestExcludedDayIsNeverPlaced:
+    def test_solo_window_skips_the_removed_date(self) -> None:
+        baseline_input, parent, child = _solo_scenario()
+        baseline = Allocator().propose(baseline_input)
+        assert _REMOVED in {d.date for d in baseline.days if d.day_type != "free"}
+
+        alloc_input, parent, child = _solo_scenario(
+            excluded=frozenset({(parent.uuid, child.id, _REMOVED)}), reuse=(child, parent)
+        )
+        proposal = Allocator().propose(alloc_input)
+
+        assert _REMOVED not in {d.date for d in proposal.days}
+        # The rest of the window is untouched.
+        assert {d.date for d in proposal.days if d.day_type != "free"} == {
+            date(2027, 2, 1),
+            date(2027, 2, 2),
+            date(2027, 2, 4),
+            date(2027, 2, 5),
+        }
+
+    def test_removed_date_is_not_reported_as_a_shortfall(self) -> None:
+        """Decision: an excluded date reduces the window's target.
+
+        The user removed it; the plan did not fail to fund it. If this
+        counted as a gap, `_build_remedies` would start proposing ways to
+        free up resources for a day nobody wants, and `sync_plan`'s eviction
+        preview would block the sync that carries out the removal.
+        """
+        _seed, parent, child = _solo_scenario()
+        alloc_input, _p, _c = _solo_scenario(
+            excluded=frozenset({(parent.uuid, child.id, _REMOVED)}), reuse=(child, parent)
+        )
+        proposal = Allocator().propose(alloc_input)
+
+        outcome = proposal.outcomes[0]
+        assert outcome.shortfall_days == 0
+        assert outcome.remedies == []
+        # `weeks_funded` still tells the truth about what was actually
+        # placed: 6 of the window's 7 days (4 funded + Sat + Sun).
+        assert outcome.weeks_funded == round(6 / 7, 2)
+
+    def test_an_unrelated_parents_exclusion_does_not_touch_this_window(self) -> None:
+        _seed, parent, child = _solo_scenario()
+        alloc_input, _p, _c = _solo_scenario(
+            excluded=frozenset({(_parent(name="Stranger").uuid, child.id, _REMOVED)}),
+            reuse=(child, parent),
+        )
+        proposal = Allocator().propose(alloc_input)
+
+        assert _REMOVED in {d.date for d in proposal.days if d.day_type != "free"}
+        assert proposal.outcomes[0].shortfall_days == 0
+
+
+class TestExclusionIsKeyedPerParent:
+    def test_both_parents_window_keeps_the_partners_day(self) -> None:
+        """The parent-keying decision, stated as a test.
+
+        Removing "this day" from A's band must not silently cancel B's leave
+        on the same date — B never asked for that, and on a shared plan they
+        would only discover it by noticing the hole.
+        """
+        alloc_input, parent_a, parent_b, child = _both_scenario()
+        baseline = Allocator().propose(alloc_input)
+        baseline_on_date = [d for d in baseline.days if d.date == _REMOVED]
+        assert {d.parent_personal_data_uuid for d in baseline_on_date} == {
+            parent_a.uuid,
+            parent_b.uuid,
+        }
+
+        alloc_input, parent_a, parent_b, child = _both_scenario(
+            excluded=frozenset({(parent_a.uuid, child.id, _REMOVED)}),
+            reuse=(child, parent_a, parent_b),
+        )
+        proposal = Allocator().propose(alloc_input)
+
+        on_date = [d for d in proposal.days if d.date == _REMOVED]
+        assert [d.parent_personal_data_uuid for d in on_date] == [parent_b.uuid]
+        assert on_date[0].day_type != "free"
+
+    def test_the_date_leaves_the_window_only_when_both_parents_are_removed(self) -> None:
+        _seed, parent_a, parent_b, child = _both_scenario()
+        alloc_input, _a, _b, _c = _both_scenario(
+            excluded=frozenset(
+                {
+                    (parent_a.uuid, child.id, _REMOVED),
+                    (parent_b.uuid, child.id, _REMOVED),
+                }
+            ),
+            reuse=(child, parent_a, parent_b),
+        )
+        proposal = Allocator().propose(alloc_input)
+
+        assert _REMOVED not in {d.date for d in proposal.days}
+        assert proposal.outcomes[0].shortfall_days == 0
+
+    def test_one_parents_exclusion_is_not_a_shortfall_for_the_window(self) -> None:
+        _seed, parent_a, parent_b, child = _both_scenario()
+        alloc_input, _a, _b, _c = _both_scenario(
+            excluded=frozenset({(parent_a.uuid, child.id, _REMOVED)}),
+            reuse=(child, parent_a, parent_b),
+        )
+        proposal = Allocator().propose(alloc_input)
+
+        assert proposal.outcomes[0].shortfall_days == 0
+
+
+class TestSwapWindowDoesNotRefillTheHole:
+    def test_the_removed_date_is_not_handed_to_the_other_parent(self) -> None:
+        """`_fund_swap`'s leftover hand-off must not undo the removal.
+
+        In a swap window exactly one parent is on leave per date, so a date
+        one parent is removed from would otherwise fall through as "unfunded
+        leftover" and be offered to the partner — the day would visibly come
+        back, just in the other parent's colour.
+        """
+        child = _child(birth_date=date(2025, 6, 1))
+        parent_a = _parent(name="A")
+        parent_b = _parent(name="B")
+        wish = _wish(
+            child_id=child.id,
+            name="Sommar",
+            start=_WINDOW_START,
+            end=_WINDOW_END,
+            weeks=1,
+            first_year=2027,
+            parent_mode="either",
+        )
+        # `parent_mode='either'` with two parents resolves to a swap window.
+        alloc_input = _build_input(
+            today=date(2027, 1, 1),
+            horizon_end=date(2027, 12, 31),
+            children=[child],
+            parents=[parent_a, parent_b],
+            pools={
+                (parent_a.uuid, child.id): DayPool(200, 90, 60),
+                (parent_b.uuid, child.id): DayPool(200, 90, 60),
+            },
+            vacation={
+                (parent_a.uuid, 2027): VacationBudget(25, 0, 0),
+                (parent_b.uuid, 2027): VacationBudget(25, 0, 0),
+            },
+            wishes=[wish],
+            excluded_days=frozenset({(parent_a.uuid, child.id, _REMOVED)}),
+        )
+        proposal = Allocator().propose(alloc_input)
+
+        assert _REMOVED not in {d.date for d in proposal.days}
+        assert proposal.outcomes[0].shortfall_days == 0
+
+
+class TestDeterminismIsPreserved:
+    def test_same_input_same_output_with_exclusions(self) -> None:
+        """§5 test #11 — the purity guarantee still holds with exclusions."""
+        _seed_input, parent, child = _solo_scenario()
+        excluded = frozenset({(parent.uuid, child.id, _REMOVED)})
+        first_input, _p, _c = _solo_scenario(excluded=excluded, reuse=(child, parent))
+        second_input, _p2, _c2 = _solo_scenario(excluded=excluded, reuse=(child, parent))
+
+        first = Allocator().propose(first_input)
+        second = Allocator().propose(second_input)
+
+        assert [(d.date, d.day_type, d.reason) for d in first.days] == [
+            (d.date, d.day_type, d.reason) for d in second.days
+        ]

backend/tests/unit/test_services/test_allocation_service.py

@@ -181,6 +181,7 @@ def _build_input(
     day_overrides: dict[date, bool] | None = None,
     age4_savable_cap: int | None = None,
     take_pl_on_red_days: bool = False,
+    excluded_days: frozenset[tuple[UUID, UUID, date]] | None = None,
 ) -> AllocationInput:
     years = {today.year, horizon_end.year, horizon_end.year + 1, *extra_holiday_years}
     if age4_savable_cap is None:
@@ -204,6 +205,7 @@ def _build_input(
         day_overrides=day_overrides or {},
         take_pl_on_red_days=take_pl_on_red_days,
         all_existing_planned=all_existing_planned,
+        excluded_days=excluded_days or frozenset(),
     )