jacobh2/F-r-ldraledigplannerare
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Separate user intent from planner output via day assertions

Browse Source 
The calendar mixed two kinds of truth in one table. `planned_leave_day` was
simultaneously the allocator's output cache, the user's override store
(`is_pinned`, plus ad-hoc rows with no `wish_id`), and the resource ledger that
analytics and the age-4 maths read. The planner therefore had to ask "am I
allowed to touch this row?" on every sync, and got it wrong at the edges.

Every user assertion is now one `day_assertion` row — a concrete `day_type`
replaces a pinned day, a row with no `wish_id` replaces an ad-hoc day, and
`day_type='none'` replaces `planned_day_exclusion`. `planned_leave_day` becomes
purely derived with a single writer, and `PlanningService.pinned_keys()` is the
single answer to "is this day pinned", used by the allocator's loader, by
`sync_plan` and by the read router alike.

On top of that, every calendar band is now a real event: an ad-hoc band opens
the same full editor as a wish-backed one and saving it promotes it to a
`LeaveWish`, so it can be named, repeated yearly, assigned to either or both
parents, and handed to the planner. "Planering" is a `moveable` toggle plus a
from/to month bound plus a separate lock/unlock action on the days themselves,
replacing a three-rung ladder whose "planner decides" rung set a search window
equal to the drawn dates and so could never move anything.

Bugs found and fixed along the way:

- The plan erased its own history. Fixed windows clip to today, so an elapsed
  auto-placed day fell into `stale_keys` and was deleted on the next sync —
  and a background sync runs on every workspace load. Past rows are now frozen
  and counted as spent.
- Migration 010's downgrade silently destroyed every pinned day and exclusion
  (`is_pinned` returned as DEFAULT 0, the exclusion table came back empty,
  exit 0, no warning). It now reconstructs both from `day_assertion`, and 009
  itemises what it cannot recover before dropping the table.
- Deleting a period left its assertions behind, locking those dates forever
  with no UI path to clear them. Wish deletion now clears them by `wish_id`.
- `DayAssertionService` and `LeaveWishService` committed multi-statement writes
  without a transaction; a crash mid-write diverged the tables or half-deleted
  a series. Both now run in a unit of work.
- A sibling year's shortfall was never surfaced: the toast only inspected the
  edited occurrence's outcome, so a fully unfunded later year rendered as an
  empty band with no warning.
- A flexible window whose bound had entirely elapsed was dropped from the
  proposal with no outcome at all. It now reports as `unplaced`.
- Unlocking a period deleted its days instead of returning them to the planner.
- The e2e global setup posted to a route deleted in this change, which would
  have failed the whole suite before its first test.

Gates: backend 938 tests / 91% coverage, frontend 1351 / 97.4 | 92.2 | 94.37 |
97.4. Migrations 009 and 010 audited against a hand-built realistic database:
the upgrade reconciles exactly and a constraint violation fails safe, leaving
the schema at 008.

Not complete. Step 4's toggle, month picker and lock/unlock action are verified
by browser walk and unit tests, but the partial-lock readout was not exercised.
`ideas.md` §7 adds a full plan for the vacation-forfeiture defect (the planner
detects expiring days and then does nothing about them) — not implemented here.
Remaining smaller items are listed in the session's restructure notes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01T4wjgbVL4HAC5Rdaw75VbV
This commit is contained in:
Jacob Hagstedt
2026-09-21 07:20:14 +02:00
parent fc90cf9a5f
commit 782415122d
101 changed files with 9542 additions and 3930 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/tests/unit/test_leave_wish_repository.py
+172 -12
View File
@@ -10,9 +10,11 @@ from uuid import UUID, uuid4
import pytest
from app.entities.day_assertion import DayAssertion
from app.entities.leave_wish import LeaveWish
from app.entities.planned_leave import PlannedLeaveDay
from app.entities.workspace import Workspace
from app.repositories_impl.sqlite.day_assertion_repository import SQLiteDayAssertionRepository
from app.repositories_impl.sqlite.leave_wish_repository import SQLiteLeaveWishRepository
from app.repositories_impl.sqlite.planned_leave_repository import SQLitePlannedLeaveRepository
from app.repositories_impl.sqlite.workspace_repository import SQLiteWorkspaceRepository
@@ -1242,7 +1244,6 @@ class TestLeaveWishServiceDeleteCascade:
seeded_ids: SeededIds,
*,
wish_id: UUID | None = None,
is_pinned: bool = False,
day: str = "2027-02-03",
) -> PlannedLeaveDay:
return PlannedLeaveDay(
@@ -1254,7 +1255,6 @@ class TestLeaveWishServiceDeleteCascade:
day_type="sjukpenning",
is_dubbeldag=False,
wish_id=wish_id,
is_pinned=is_pinned,
created_at=datetime.now(),
updated_at=datetime.now(),
)
@@ -1284,25 +1284,57 @@ class TestLeaveWishServiceDeleteCascade:
leave_wish_service: LeaveWishService,
leave_wish_repo: SQLiteLeaveWishRepository,
planned_leave_repo: SQLitePlannedLeaveRepository,
day_assertion_repo: SQLiteDayAssertionRepository,
seeded_ids: SeededIds,
) -> None:
"""A pinned day dies with its wish rather than surviving as ad-hoc.
"""A pinned day dies with its wish rather than surviving as ad-hoc —
Pinning only protects a day from being silently retyped/reassigned
by a later `sync_plan` re-plan — it is not a signal that the day
should outlive a period the user explicitly chose to delete. This
also matches the ad-hoc-period delete path in `Calendar.tsx`
(`handleDeletePeriod`'s no-`wishId` branch), which already deletes
every day in the band regardless of `is_pinned`.
and so does its `DayAssertion` (restructure step 3b). Pinning only
protects a day from being silently retyped/reassigned by a later
`sync_plan` re-plan — it is not a signal that the day should outlive
a period the user explicitly chose to delete. This also matches the
ad-hoc-period delete path in `Calendar.tsx` (`handleDeletePeriod`'s
no-`wishId` branch), which already deletes every day in the band
regardless of pin state.
`LeaveWishRepository.delete_by_wish` itself never looked at
`is_pinned` (it deleted by `wish_id` alone even before that column
existed) — the row-level cascade was never in doubt. What step 3b
adds is `LeaveWishService._clear_assertions_for`, which is what this
test's `day_assertion_repo` assertion actually exercises: without
it, this assertion would survive with no row left to attach to, see
`TestWishDeleteClearsAssertions` in
test_services/test_allocation_day_assertion.py for the full
stray-slot scenario this prevents.
"""
wish = await leave_wish_repo.create(_make(workspace_id=seeded_ids.workspace_id))
pinned = await planned_leave_repo.create(
self._make_day(seeded_ids, wish_id=wish.id, is_pinned=True)
pinned = await planned_leave_repo.create(self._make_day(seeded_ids, wish_id=wish.id))
await day_assertion_repo.create(
DayAssertion(
id=uuid4(),
workspace_id=seeded_ids.workspace_id,
child_id=seeded_ids.child_id,
parent_personal_data_uuid=seeded_ids.personal_data_uuid,
date=pinned.date,
day_type=pinned.day_type,
wish_id=wish.id,
created_at=datetime.now(),
updated_at=datetime.now(),
)
)
await leave_wish_service.delete(wish.id)
assert await planned_leave_repo.get_by_id(pinned.id) is None
assert (
await day_assertion_repo.get_by_natural_key(
seeded_ids.workspace_id,
seeded_ids.child_id,
seeded_ids.personal_data_uuid,
pinned.date,
)
is None
)
async def test_delete_leaves_a_different_wishs_days_untouched(
self,
@@ -1346,6 +1378,70 @@ class TestLeaveWishServiceDeleteCascade:
assert survivor.wish_id is None
class TestLeaveWishServiceAtomicity:
"""Bug 3 (adversarial-review-adjacent) — `LeaveWishService` previously had
NO unit of work at all, so `delete()`'s multi-row loop (clear assertions
-> delete `planned_leave_day` rows -> delete the `LeaveWish` row, once
per targeted occurrence) committed each statement immediately. A crash
partway through a `scope='series'` delete left some years fully deleted
and others untouched. `leave_wish_service_with_uow` wires a real
`SQLiteUnitOfWork`, matching `PlanningService`'s established pattern —
this proves a failure mid-loop now rolls the WHOLE delete back.
"""
async def test_failure_mid_series_delete_leaves_every_row_untouched(
self,
leave_wish_service_with_uow: LeaveWishService,
leave_wish_repo: SQLiteLeaveWishRepository,
planned_leave_repo: SQLitePlannedLeaveRepository,
seeded_ids: SeededIds,
monkeypatch: pytest.MonkeyPatch,
) -> None:
series_id = uuid4()
year1 = await leave_wish_repo.create(
_make(workspace_id=seeded_ids.workspace_id, first_year=2027, series_id=series_id)
)
year2 = await leave_wish_repo.create(
_make(workspace_id=seeded_ids.workspace_id, first_year=2028, series_id=series_id)
)
day1 = 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=date(2027, 6, 15),
day_type="sjukpenning",
wish_id=year1.id,
created_at=datetime.now(),
updated_at=datetime.now(),
)
)
real_delete = leave_wish_repo.delete
call_count = 0
async def flaky_delete(wish_id: UUID) -> None:
nonlocal call_count
call_count += 1
if call_count == 2:
raise RuntimeError("simulated crash mid-series-delete")
await real_delete(wish_id)
monkeypatch.setattr(leave_wish_repo, "delete", flaky_delete)
with pytest.raises(RuntimeError):
await leave_wish_service_with_uow.delete(year1.id, scope="series")
# Neither year's LeaveWish row nor its planned_leave_day row was
# actually removed — the first successful delete was rolled back
# along with the second (failed) one.
assert await leave_wish_repo.get_by_id(year1.id) is not None
assert await leave_wish_repo.get_by_id(year2.id) is not None
assert await planned_leave_repo.get_by_id(day1.id) is not None
class TestLeaveWishSeriesMaterialisation:
"""A repeating wish is stored as one row per year, sharing a `series_id`.
@@ -1588,7 +1684,6 @@ class TestLeaveWishSeriesMaterialisation:
day_type="sjukpenning",
is_dubbeldag=False,
wish_id=dropped.id,
is_pinned=False,
created_at=datetime.now(),
updated_at=datetime.now(),
)
@@ -1688,6 +1783,71 @@ class TestLeaveWishSeriesMaterialisation:
assert await leave_wish_repo.get_by_workspace(seeded_ids.workspace_id) == []
async def test_delete_series_clears_every_occurrences_assertion_not_just_the_clicked_year(
self,
leave_wish_service: LeaveWishService,
leave_wish_repo: SQLiteLeaveWishRepository,
planned_leave_repo: SQLitePlannedLeaveRepository,
day_assertion_repo: SQLiteDayAssertionRepository,
seeded_ids: SeededIds,
) -> None:
"""`scope='series'` deletes every occurrence's rows (restructure
step 3b: and their assertions), not just the clicked year's — the
cleanup must not accidentally narrow to a single occurrence the way
the pre-materialisation single-row shape used to force.
"""
_, rows = await self._series(leave_wish_service, leave_wish_repo, seeded_ids)
middle = next(r for r in rows if r.first_year == 2028)
planned_by_year: dict[int, PlannedLeaveDay] = {}
for occurrence in rows:
day = date(
occurrence.first_year, occurrence.window_start_month, occurrence.window_start_day
)
planned = 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="vacation",
wish_id=occurrence.id,
created_at=datetime.now(),
updated_at=datetime.now(),
)
)
planned_by_year[occurrence.first_year] = planned
await day_assertion_repo.create(
DayAssertion(
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="vacation",
wish_id=occurrence.id,
created_at=datetime.now(),
updated_at=datetime.now(),
)
)
await leave_wish_service.delete(middle.id, scope="series")
for occurrence in rows:
planned = planned_by_year[occurrence.first_year]
assert await planned_leave_repo.get_by_id(planned.id) is None
assert (
await day_assertion_repo.get_by_natural_key(
seeded_ids.workspace_id,
seeded_ids.child_id,
seeded_ids.personal_data_uuid,
planned.date,
)
is None
), f"assertion for {occurrence.first_year} survived a series-scoped delete"
async def test_delete_series_on_a_standalone_wish_removes_just_it(
self,
leave_wish_service: LeaveWishService,