dev_agent
c313e1c56f
Co-authored-by: dev_agent <17+dev_agent@code.cubecraftcreations.com> Co-committed-by: dev_agent <17+dev_agent@code.cubecraftcreations.com>
1012 lines
36 KiB
Python
1012 lines
36 KiB
Python
"""Admin-plane presence route tests (task e4a9d31b; schema 9 patterns).
|
|
|
|
These tests exercise the admin plane's presence routes against the ASGI
|
|
app with httpx, reusing the shared local-RSA-key/stubbed-JWKS harness
|
|
(:mod:`tests.admin_jwt_harness`) so an admin JWT genuinely
|
|
authenticates — signature, issuer, audience, expiry and the
|
|
nestquest-admins group — with NO network access.
|
|
|
|
Every done-condition case is proven against the DATABASE and the DOMAIN,
|
|
read through the SAME core copy the app uses (``nestquest_core.*``; see
|
|
the two-copy caveat in api/nestquest_core.py):
|
|
|
|
- Authentication runs through the router's ONE ``require_admin``
|
|
dependency on EVERY presence route (the four pattern routes and the
|
|
override routes): an admin JWT passes, a JWT without the group or the
|
|
panel service token is 403, an absent credential is 401 — and
|
|
nothing is written.
|
|
- ``POST /api/v1/admin/children/{id}/presence-patterns`` ADDS a
|
|
pattern: a child has zero or more, each create inserts a new row
|
|
(never replacing an earlier one). ``PATCH
|
|
/api/v1/admin/presence-patterns/{id}`` changes only the supplied
|
|
fields; ``DELETE`` removes the one pattern. The removed one-per-child
|
|
``/presence-schedule`` route no longer exists.
|
|
- ``POST /api/v1/admin/presence-overrides`` creates the override (its
|
|
``id`` comes back) and ``DELETE /api/v1/admin/presence-overrides/{id}``
|
|
removes it again.
|
|
- The child's RESOLVED presence changes accordingly: the pure
|
|
:class:`~nestquest_core.presence.PresenceEngine` built from the
|
|
stored rows answers differently before/after each write — a home
|
|
pattern restricts the child's present weekdays, an away pattern beats
|
|
a home one, an override beats every pattern for its range, and
|
|
deleting the override (or the pattern) restores the earlier answer.
|
|
- The regeneration side effect lives in the core layer the route
|
|
calls: adding an all-absent home pattern through the route deletes
|
|
the child's future open quest instances and they are NOT rebuilt
|
|
while the child is absent every day; deleting that pattern rebuilds
|
|
them — the same proof the HA service test makes, through the API.
|
|
|
|
Error mapping (documented in api/routes_admin.py): a core ValueError
|
|
for a non-existent child (pattern or override create) is 404 "Child not
|
|
found", a non-existent pattern (edit/delete) 404 "Presence pattern not
|
|
found", a non-existent override (delete) 404; every other core
|
|
ValueError — a rejected pattern (name, kind, cycle length, pattern
|
|
coverage, anchor date) or override (malformed or inverted dates, an
|
|
overlapping range) — is 422 naming the field, the same failure class
|
|
FastAPI reports for malformed bodies.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import datetime
|
|
import importlib
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from tests.admin_jwt_harness import (
|
|
ADMIN_KEY,
|
|
KID,
|
|
AdminRunner,
|
|
jwks_for,
|
|
make_token,
|
|
)
|
|
|
|
# The presence model, DAOs, business layer and materializer through the
|
|
# SAME core copy the app uses (nestquest_core.*, NOT the conftest-stubbed
|
|
# custom_components copy) — used for the tests' database and resolved-
|
|
# presence assertions only; the routes reach them through api.nestquest_core.
|
|
_children = importlib.import_module("nestquest_core.children")
|
|
_dao_presence = importlib.import_module("nestquest_core.dao_presence")
|
|
_dao_instances = importlib.import_module("nestquest_core.dao_instances")
|
|
_materialize = importlib.import_module("nestquest_core.materialize")
|
|
_presence = importlib.import_module("nestquest_core.presence")
|
|
|
|
#: A Monday anchoring every pattern: cycle week 0 starts here.
|
|
ANCHOR_MONDAY = "2026-01-05"
|
|
#: The Tuesday of that week — absent under the test home pattern.
|
|
TUESDAY = "2026-01-06"
|
|
|
|
#: The panel service token the harness app is configured with.
|
|
HARNESS_PANEL_TOKEN = "admin-test-panel-token"
|
|
|
|
#: The 403 detail for the panel service token on an admin route.
|
|
PANEL_TOKEN_REJECTION_DETAIL = (
|
|
"This credential type is not accepted for admin access"
|
|
)
|
|
|
|
#: The 403 detail for a valid JWT without the admin group.
|
|
FORBIDDEN_DETAIL = (
|
|
"Admin access requires membership in the nestquest-admins group"
|
|
)
|
|
|
|
|
|
def _admin_headers() -> dict[str, str]:
|
|
"""The Authorization header of a valid nestquest-admins JWT."""
|
|
return {"Authorization": f"Bearer {make_token()}"}
|
|
|
|
|
|
def _patterns_url(child_id: int) -> str:
|
|
"""The child-scoped pattern list/create route."""
|
|
return f"/api/v1/admin/children/{child_id}/presence-patterns"
|
|
|
|
|
|
def _pattern_url(pattern_id: int | str) -> str:
|
|
"""The id-scoped pattern edit/delete route."""
|
|
return f"/api/v1/admin/presence-patterns/{pattern_id}"
|
|
|
|
|
|
def _pattern_body(
|
|
cycle_length_weeks: object = 1,
|
|
pattern: dict[str, object] | None = None,
|
|
*,
|
|
name: object = "Mum's house",
|
|
kind: object = "home",
|
|
anchor_date: object = ANCHOR_MONDAY,
|
|
) -> dict[str, object]:
|
|
"""A valid pattern body anchored to the test Monday (Mon/Wed/Fri home)."""
|
|
return {
|
|
"name": name,
|
|
"kind": kind,
|
|
"cycle_length_weeks": cycle_length_weeks,
|
|
"anchor_date": anchor_date,
|
|
"pattern": {"0": [0, 2, 4]} if pattern is None else pattern,
|
|
}
|
|
|
|
|
|
def _override_body(
|
|
child_id: int,
|
|
*,
|
|
start_date: str = TUESDAY,
|
|
end_date: str = TUESDAY,
|
|
is_present: bool = True,
|
|
) -> dict[str, object]:
|
|
"""A valid single-day override body for the test child."""
|
|
return {
|
|
"child_id": child_id,
|
|
"start_date": start_date,
|
|
"end_date": end_date,
|
|
"is_present": is_present,
|
|
"note": "grandmother's week",
|
|
}
|
|
|
|
|
|
def _detail_names(response: object, field: str) -> bool:
|
|
"""True when a 422's detail names ``field``.
|
|
|
|
A core ValueError arrives as a string detail naming the field; a
|
|
Pydantic shape failure as a list of errors whose ``loc`` holds it.
|
|
"""
|
|
detail = response.json()["detail"]
|
|
if isinstance(detail, str):
|
|
return field in detail
|
|
return any(field in [str(part) for part in error["loc"]] for error in detail)
|
|
|
|
|
|
async def _create_child(client: object, name: str = "Ada") -> int:
|
|
"""Create one child through the admin children route; return the id."""
|
|
created = await client.post(
|
|
"/api/v1/admin/children",
|
|
json={"display_name": name},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert created.status_code == 201
|
|
return created.json()["id"]
|
|
|
|
|
|
async def _create_pattern(
|
|
client: object, child_id: int, body: dict[str, object] | None = None
|
|
) -> dict[str, object]:
|
|
"""Create one pattern through the admin route; return the payload."""
|
|
created = await client.post(
|
|
_patterns_url(child_id),
|
|
json=_pattern_body() if body is None else body,
|
|
headers=_admin_headers(),
|
|
)
|
|
assert created.status_code == 201, created.text
|
|
return created.json()
|
|
|
|
|
|
def _engine(
|
|
database: object,
|
|
child_id: int,
|
|
pattern_records: list[object],
|
|
override_records: list[object],
|
|
) -> object:
|
|
"""Build the pure PresenceEngine from stored rows (the snapshot shape).
|
|
|
|
Mirrors what the core snapshot builder assembles: the child's
|
|
decoded patterns (none → present every day) plus its overrides,
|
|
so :meth:`PresenceEngine.is_present` answers from the SAME rows the
|
|
routes produced.
|
|
"""
|
|
patterns = {
|
|
child_id: [
|
|
_presence.PresencePattern.decode(
|
|
record.child_id,
|
|
record.name,
|
|
record.kind,
|
|
record.anchor_date,
|
|
record.pattern,
|
|
)
|
|
for record in pattern_records
|
|
]
|
|
}
|
|
overrides = {
|
|
child_id: [
|
|
_presence.PresenceOverride(
|
|
record.child_id,
|
|
record.start_date,
|
|
record.end_date,
|
|
record.is_present,
|
|
note=record.note,
|
|
)
|
|
for record in override_records
|
|
]
|
|
}
|
|
return _presence.PresenceEngine(patterns, overrides)
|
|
|
|
|
|
async def _child_state(
|
|
database: object, child_id: int
|
|
) -> tuple[list[object], list[object], object]:
|
|
"""The child's stored pattern records, overrides and PresenceEngine."""
|
|
pattern_records = await _dao_presence.PresencePatternsDao(
|
|
database
|
|
).list_by_child(child_id)
|
|
override_records = await _dao_presence.PresenceOverridesDao(
|
|
database
|
|
).list_by_child_and_range(child_id, "2020-01-01", "2030-01-01")
|
|
engine = _engine(database, child_id, pattern_records, override_records)
|
|
return pattern_records, override_records, engine
|
|
|
|
|
|
@pytest.fixture
|
|
async def admin_presence(temp_db_path: str) -> SimpleNamespace:
|
|
"""An admin-plane app client plus its live database.
|
|
|
|
The same runner the auth, children and quest-definition tests use
|
|
(stubbed JWKS, no network); the fixture also exposes the app's ONE
|
|
database connection so tests assert the routes' effects on the
|
|
stored rows and the resolved presence built from them.
|
|
"""
|
|
runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
|
|
async with runner as client:
|
|
yield SimpleNamespace(
|
|
client=client,
|
|
database=runner.app.state.db.database,
|
|
)
|
|
|
|
|
|
# --- authentication: the ONE require_admin dependency guards every route ---
|
|
|
|
|
|
async def test_presence_routes_refuse_non_admin_and_absent_credentials(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""A non-admin JWT is 403, an absent credential is 401: nothing written."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
non_admin = make_token(groups=("some-other-group",))
|
|
non_admin_headers = {"Authorization": f"Bearer {non_admin}"}
|
|
|
|
forbidden_pattern = await client.post(
|
|
_patterns_url(child_id),
|
|
json=_pattern_body(),
|
|
headers=non_admin_headers,
|
|
)
|
|
assert forbidden_pattern.status_code == 403
|
|
assert forbidden_pattern.json()["detail"] == FORBIDDEN_DETAIL
|
|
|
|
forbidden_override = await client.post(
|
|
"/api/v1/admin/presence-overrides",
|
|
json=_override_body(child_id),
|
|
headers=non_admin_headers,
|
|
)
|
|
assert forbidden_override.status_code == 403
|
|
|
|
forbidden_delete = await client.delete(
|
|
"/api/v1/admin/presence-overrides/1", headers=non_admin_headers
|
|
)
|
|
assert forbidden_delete.status_code == 403
|
|
|
|
unauthenticated_pattern = await client.post(
|
|
_patterns_url(child_id), json=_pattern_body()
|
|
)
|
|
assert unauthenticated_pattern.status_code == 401
|
|
|
|
unauthenticated_override = await client.post(
|
|
"/api/v1/admin/presence-overrides", json=_override_body(child_id)
|
|
)
|
|
assert unauthenticated_override.status_code == 401
|
|
|
|
unauthenticated_delete = await client.delete(
|
|
"/api/v1/admin/presence-overrides/1"
|
|
)
|
|
assert unauthenticated_delete.status_code == 401
|
|
|
|
# No route ran its handler: the child still has no pattern and no
|
|
# overrides (and is present every day, the no-pattern default).
|
|
patterns, overrides, engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert patterns == []
|
|
assert overrides == []
|
|
assert engine.is_present(child_id, ANCHOR_MONDAY) is True
|
|
|
|
|
|
def _non_admin_headers() -> dict[str, str]:
|
|
return {
|
|
"Authorization": (
|
|
f"Bearer {make_token(groups=('some-other-group',))}"
|
|
)
|
|
}
|
|
|
|
|
|
_CREDENTIALS = {
|
|
"absent": (lambda: {}, 401, None),
|
|
"panel-token": (
|
|
lambda: {"Authorization": f"Bearer {HARNESS_PANEL_TOKEN}"},
|
|
403,
|
|
PANEL_TOKEN_REJECTION_DETAIL,
|
|
),
|
|
"non-admin-jwt": (_non_admin_headers, 403, FORBIDDEN_DETAIL),
|
|
}
|
|
|
|
|
|
@pytest.mark.parametrize("credential", sorted(_CREDENTIALS))
|
|
@pytest.mark.parametrize("route", ["list", "create", "edit", "delete"])
|
|
async def test_pattern_routes_enforce_admin_auth(
|
|
admin_presence: SimpleNamespace, route: str, credential: str
|
|
) -> None:
|
|
"""Every pattern route rejects absent, panel and non-admin credentials.
|
|
|
|
Each refused request leaves the stored pattern exactly as it was: a
|
|
refused create adds no row, a refused edit changes nothing, a
|
|
refused delete removes nothing.
|
|
"""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
existing = await _create_pattern(client, child_id)
|
|
make_headers, status, detail = _CREDENTIALS[credential]
|
|
|
|
if route == "list":
|
|
response = await client.get(
|
|
_patterns_url(child_id), headers=make_headers()
|
|
)
|
|
elif route == "create":
|
|
response = await client.post(
|
|
_patterns_url(child_id),
|
|
json=_pattern_body(name="Dad's house"),
|
|
headers=make_headers(),
|
|
)
|
|
elif route == "edit":
|
|
response = await client.patch(
|
|
_pattern_url(existing["id"]),
|
|
json={"name": "Renamed"},
|
|
headers=make_headers(),
|
|
)
|
|
else:
|
|
response = await client.delete(
|
|
_pattern_url(existing["id"]), headers=make_headers()
|
|
)
|
|
|
|
assert response.status_code == status
|
|
if detail is not None:
|
|
assert response.json()["detail"] == detail
|
|
listed = await client.get(_patterns_url(child_id), headers=_admin_headers())
|
|
assert listed.json() == {"patterns": [existing]}
|
|
|
|
|
|
# --- the removed one-per-child schedule route ----------------------------------
|
|
|
|
|
|
async def test_old_presence_schedule_route_is_gone(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""PUT/GET /presence-schedule no longer exist; nothing is written."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
url = f"/api/v1/admin/children/{child_id}/presence-schedule"
|
|
|
|
put = await client.put(
|
|
url,
|
|
json={
|
|
"cycle_length_weeks": 1,
|
|
"anchor_date": ANCHOR_MONDAY,
|
|
"pattern": {"0": [0]},
|
|
},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert put.status_code in (404, 405)
|
|
get = await client.get(url, headers=_admin_headers())
|
|
assert get.status_code in (404, 405)
|
|
patterns, _overrides, _engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert patterns == []
|
|
|
|
|
|
# --- pattern create ---------------------------------------------------------
|
|
|
|
|
|
async def test_pattern_create_persists_and_adds_a_row_per_create(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""POST /presence-patterns persists; a second POST ADDS another row."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
|
|
first = await client.post(
|
|
_patterns_url(child_id),
|
|
json=_pattern_body(),
|
|
headers=_admin_headers(),
|
|
)
|
|
assert first.status_code == 201
|
|
first_payload = first.json()
|
|
assert first_payload == {
|
|
"id": first_payload["id"],
|
|
"child_id": child_id,
|
|
"name": "Mum's house",
|
|
"kind": "home",
|
|
"cycle_length_weeks": 1,
|
|
"anchor_date": ANCHOR_MONDAY,
|
|
"pattern": {"0": [0, 2, 4]},
|
|
}
|
|
# Database proof: ONE pattern row, stored as encoded CSV.
|
|
patterns, _overrides, _engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert [record.id for record in patterns] == [first_payload["id"]]
|
|
assert patterns[0].name == "Mum's house"
|
|
assert patterns[0].kind == "home"
|
|
assert patterns[0].cycle_length_weeks == 1
|
|
assert patterns[0].anchor_date == ANCHOR_MONDAY
|
|
assert patterns[0].pattern == "0,2,4"
|
|
|
|
# Creating again ADDS a second pattern beside the first — the first
|
|
# row is untouched (schema 9 has no one-per-child constraint).
|
|
second = await client.post(
|
|
_patterns_url(child_id),
|
|
json=_pattern_body(
|
|
cycle_length_weeks=2,
|
|
pattern={"0": [], "1": [3, 1]},
|
|
name=" Holiday rota ",
|
|
kind="away",
|
|
),
|
|
headers=_admin_headers(),
|
|
)
|
|
assert second.status_code == 201
|
|
second_payload = second.json()
|
|
assert second_payload == {
|
|
"id": second_payload["id"],
|
|
"child_id": child_id,
|
|
"name": "Holiday rota",
|
|
"kind": "away",
|
|
"cycle_length_weeks": 2,
|
|
"anchor_date": ANCHOR_MONDAY,
|
|
"pattern": {"0": [], "1": [1, 3]},
|
|
}
|
|
assert second_payload["id"] != first_payload["id"]
|
|
patterns, _overrides, _engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert [record.id for record in patterns] == [
|
|
first_payload["id"],
|
|
second_payload["id"],
|
|
]
|
|
assert patterns[0].pattern == "0,2,4"
|
|
assert patterns[1].pattern == "|1,3"
|
|
|
|
|
|
async def test_pattern_changes_the_childs_resolved_presence(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""The resolved presence (PresenceEngine) follows the stored patterns."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
|
|
# Before any pattern the child is present every day.
|
|
_patterns, _overrides, engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert engine.is_present(child_id, ANCHOR_MONDAY) is True
|
|
assert engine.is_present(child_id, TUESDAY) is True
|
|
|
|
# Home Mon/Wed/Fri only, week 0 of a one-week cycle.
|
|
await _create_pattern(client, child_id)
|
|
_patterns, _overrides, engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert engine.is_present(child_id, ANCHOR_MONDAY) is True
|
|
assert engine.is_present(child_id, TUESDAY) is False
|
|
|
|
# An away pattern covering Monday beats the home pattern there.
|
|
await _create_pattern(
|
|
client,
|
|
child_id,
|
|
_pattern_body(pattern={"0": [0]}, name="Swim camp", kind="away"),
|
|
)
|
|
_patterns, _overrides, engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert engine.is_present(child_id, ANCHOR_MONDAY) is False
|
|
assert engine.is_present(child_id, "2026-01-07") is True # Wednesday
|
|
assert engine.is_present(child_id, TUESDAY) is False
|
|
|
|
|
|
async def test_pattern_writes_regenerate_future_instances(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""An all-absent home pattern deletes the child's future instances.
|
|
|
|
The regeneration side effect lives in the core layer the route
|
|
calls: the child's open instances at or after today are deleted
|
|
across ALL its definitions and NOT rebuilt while the child is
|
|
absent every day; deleting the pattern rebuilds them.
|
|
"""
|
|
client = admin_presence.client
|
|
database = admin_presence.database
|
|
child_id = await _create_child(client)
|
|
created = await client.post(
|
|
"/api/v1/admin/quest-definitions",
|
|
json={
|
|
"title": "Brush teeth",
|
|
"rule": {"rule_type": "daily"},
|
|
"assignee_child_ids": [child_id],
|
|
"windows": ["morning"],
|
|
},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert created.status_code == 201
|
|
|
|
today = datetime.date.today()
|
|
start = today.isoformat()
|
|
end = (today + datetime.timedelta(days=14)).isoformat()
|
|
await _materialize.materialize(database, start, end, today=today)
|
|
instances = _dao_instances.QuestInstancesDao(database)
|
|
assert await instances.list_by_date_range(child_id, start, end)
|
|
|
|
# The route's write must regenerate: a home pattern covering no day
|
|
# makes the child absent every day and removes every open instance.
|
|
pattern = await _create_pattern(
|
|
client, child_id, _pattern_body(pattern={"0": []})
|
|
)
|
|
assert await instances.list_by_date_range(child_id, start, end) == []
|
|
|
|
# Deleting it regenerates too: present every day again, rebuilt.
|
|
deleted = await client.delete(
|
|
_pattern_url(pattern["id"]), headers=_admin_headers()
|
|
)
|
|
assert deleted.status_code == 200
|
|
assert await instances.list_by_date_range(child_id, start, end)
|
|
|
|
|
|
async def test_pattern_edit_regenerates_future_instances(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""PATCH regenerates: flipping an empty home pattern to away rebuilds."""
|
|
client = admin_presence.client
|
|
database = admin_presence.database
|
|
child_id = await _create_child(client)
|
|
created = await client.post(
|
|
"/api/v1/admin/quest-definitions",
|
|
json={
|
|
"title": "Brush teeth",
|
|
"rule": {"rule_type": "daily"},
|
|
"assignee_child_ids": [child_id],
|
|
"windows": ["morning"],
|
|
},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert created.status_code == 201
|
|
today = datetime.date.today()
|
|
start = today.isoformat()
|
|
end = (today + datetime.timedelta(days=14)).isoformat()
|
|
pattern = await _create_pattern(
|
|
client, child_id, _pattern_body(pattern={"0": []})
|
|
)
|
|
await _materialize.materialize(database, start, end, today=today)
|
|
instances = _dao_instances.QuestInstancesDao(database)
|
|
assert await instances.list_by_date_range(child_id, start, end) == []
|
|
|
|
# An away pattern covering no day leaves no home pattern: present
|
|
# every day, so the edit's regeneration builds the instances.
|
|
edited = await client.patch(
|
|
_pattern_url(pattern["id"]),
|
|
json={"kind": "away"},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert edited.status_code == 200
|
|
assert await instances.list_by_date_range(child_id, start, end)
|
|
|
|
|
|
# --- pattern edit (PATCH) ------------------------------------------------------
|
|
|
|
|
|
async def test_pattern_patch_changes_only_supplied_fields(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""A partial PATCH changes the supplied fields and keeps the rest."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
original = await _create_pattern(client, child_id)
|
|
sibling = await _create_pattern(
|
|
client, child_id, _pattern_body(name="Sibling", kind="away")
|
|
)
|
|
|
|
renamed = await client.patch(
|
|
_pattern_url(original["id"]),
|
|
json={"name": "Weekday home"},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert renamed.status_code == 200
|
|
assert renamed.json() == dict(original, name="Weekday home")
|
|
|
|
reshaped = await client.patch(
|
|
_pattern_url(original["id"]),
|
|
json={"cycle_length_weeks": 2, "pattern": {"0": [1], "1": [6, 5]}},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert reshaped.status_code == 200
|
|
assert reshaped.json() == dict(
|
|
original,
|
|
name="Weekday home",
|
|
cycle_length_weeks=2,
|
|
pattern={"0": [1], "1": [5, 6]},
|
|
)
|
|
|
|
moved = await client.patch(
|
|
_pattern_url(original["id"]),
|
|
json={"anchor_date": "2026-01-12", "kind": "away"},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert moved.status_code == 200
|
|
expected = dict(
|
|
reshaped.json(), anchor_date="2026-01-12", kind="away"
|
|
)
|
|
assert moved.json() == expected
|
|
|
|
# Database proof: the edited row, same id, and the sibling untouched.
|
|
patterns, _overrides, _engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert [record.id for record in patterns] == [
|
|
original["id"],
|
|
sibling["id"],
|
|
]
|
|
assert patterns[0].name == "Weekday home"
|
|
assert patterns[0].kind == "away"
|
|
assert patterns[0].cycle_length_weeks == 2
|
|
assert patterns[0].anchor_date == "2026-01-12"
|
|
assert patterns[0].pattern == "1|5,6"
|
|
listed = await client.get(_patterns_url(child_id), headers=_admin_headers())
|
|
assert listed.json() == {"patterns": [expected, sibling]}
|
|
|
|
|
|
async def test_pattern_patch_unknown_id_is_404(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""Editing a pattern id that does not exist is 404."""
|
|
response = await admin_presence.client.patch(
|
|
_pattern_url(999), json={"name": "Nope"}, headers=_admin_headers()
|
|
)
|
|
assert response.status_code == 404
|
|
assert response.json()["detail"] == "Presence pattern not found"
|
|
|
|
malformed = await admin_presence.client.patch(
|
|
_pattern_url("not-an-id"),
|
|
json={"name": "Nope"},
|
|
headers=_admin_headers(),
|
|
)
|
|
assert malformed.status_code == 422
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("edit", "field"),
|
|
[
|
|
({"name": ""}, "name"),
|
|
({"name": " "}, "name"),
|
|
({"name": None}, "name"),
|
|
({"kind": "sometimes"}, "kind"),
|
|
({"kind": None}, "kind"),
|
|
({"cycle_length_weeks": 0}, "cycle_length_weeks"),
|
|
({"cycle_length_weeks": 5}, "cycle_length_weeks"),
|
|
({"cycle_length_weeks": 2.5}, "cycle_length_weeks"),
|
|
({"cycle_length_weeks": "2"}, "cycle_length_weeks"),
|
|
({"cycle_length_weeks": None}, "cycle_length_weeks"),
|
|
# A longer cycle without a matching pattern leaves week 1 uncovered.
|
|
({"cycle_length_weeks": 2}, "pattern"),
|
|
({"anchor_date": "2026-13-40"}, "anchor_date"),
|
|
({"anchor_date": None}, "anchor_date"),
|
|
({"pattern": {}}, "pattern"),
|
|
({"pattern": None}, "pattern"),
|
|
({"pattern": {"0": [7]}}, "pattern"), # weekday out of 0..6
|
|
# Strict JSON integer weekdays: no bool, string or float coercion.
|
|
({"pattern": {"0": [True]}}, "pattern"),
|
|
({"pattern": {"0": [False]}}, "pattern"),
|
|
({"pattern": {"0": ["1"]}}, "pattern"),
|
|
({"pattern": {"0": [1.0]}}, "pattern"),
|
|
],
|
|
)
|
|
async def test_rejected_pattern_patch_is_422_and_changes_nothing(
|
|
admin_presence: SimpleNamespace, edit: dict[str, object], field: str
|
|
) -> None:
|
|
"""A rejected edit (incl. explicit null) is 422 naming the field."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
original = await _create_pattern(client, child_id)
|
|
|
|
response = await client.patch(
|
|
_pattern_url(original["id"]), json=edit, headers=_admin_headers()
|
|
)
|
|
assert response.status_code == 422, response.text
|
|
assert _detail_names(response, field), response.json()
|
|
listed = await client.get(_patterns_url(child_id), headers=_admin_headers())
|
|
assert listed.json() == {"patterns": [original]}
|
|
|
|
|
|
# --- pattern delete ------------------------------------------------------------
|
|
|
|
|
|
async def test_pattern_delete_removes_one_pattern_and_presence_resolves(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""DELETE removes the one pattern; its siblings and presence follow."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
home = await _create_pattern(client, child_id)
|
|
away = await _create_pattern(
|
|
client,
|
|
child_id,
|
|
_pattern_body(pattern={"0": [0]}, name="Swim camp", kind="away"),
|
|
)
|
|
_patterns, _overrides, engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert engine.is_present(child_id, ANCHOR_MONDAY) is False
|
|
|
|
deleted = await client.delete(
|
|
_pattern_url(away["id"]), headers=_admin_headers()
|
|
)
|
|
assert deleted.status_code == 200
|
|
assert deleted.json() == {"status": "ok"}
|
|
assert (
|
|
await _dao_presence.PresencePatternsDao(admin_presence.database).get(
|
|
away["id"]
|
|
)
|
|
is None
|
|
)
|
|
patterns, _overrides, engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert [record.id for record in patterns] == [home["id"]]
|
|
assert engine.is_present(child_id, ANCHOR_MONDAY) is True
|
|
assert engine.is_present(child_id, TUESDAY) is False
|
|
|
|
# Deleting the last pattern: present every day again.
|
|
deleted = await client.delete(
|
|
_pattern_url(home["id"]), headers=_admin_headers()
|
|
)
|
|
assert deleted.status_code == 200
|
|
patterns, _overrides, engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert patterns == []
|
|
assert engine.is_present(child_id, TUESDAY) is True
|
|
|
|
# A second delete of the same id is 404: it no longer exists.
|
|
again = await client.delete(
|
|
_pattern_url(home["id"]), headers=_admin_headers()
|
|
)
|
|
assert again.status_code == 404
|
|
assert again.json()["detail"] == "Presence pattern not found"
|
|
|
|
|
|
async def test_delete_unknown_pattern_is_404(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""Deleting a pattern id that does not exist is 404."""
|
|
response = await admin_presence.client.delete(
|
|
_pattern_url(999), headers=_admin_headers()
|
|
)
|
|
assert response.status_code == 404
|
|
assert response.json()["detail"] == "Presence pattern not found"
|
|
|
|
malformed = await admin_presence.client.delete(
|
|
_pattern_url("not-an-id"), headers=_admin_headers()
|
|
)
|
|
assert malformed.status_code == 422
|
|
|
|
|
|
# --- override create + delete -----------------------------------------------
|
|
|
|
|
|
async def test_override_is_created_then_deleted_and_presence_resolves(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""POST creates the override, DELETE removes it; presence follows."""
|
|
client = admin_presence.client
|
|
database = admin_presence.database
|
|
child_id = await _create_child(client)
|
|
await _create_pattern(client, child_id)
|
|
|
|
# Create: the override comes back with its id and the posted shape.
|
|
created = await client.post(
|
|
"/api/v1/admin/presence-overrides",
|
|
json=_override_body(child_id),
|
|
headers=_admin_headers(),
|
|
)
|
|
assert created.status_code == 201
|
|
payload = created.json()
|
|
assert set(payload) == {
|
|
"id",
|
|
"child_id",
|
|
"start_date",
|
|
"end_date",
|
|
"is_present",
|
|
"note",
|
|
}
|
|
assert payload["child_id"] == child_id
|
|
assert payload["start_date"] == TUESDAY
|
|
assert payload["end_date"] == TUESDAY
|
|
assert payload["is_present"] is True
|
|
assert payload["note"] == "grandmother's week"
|
|
|
|
# Database proof: the row exists — and the RESOLVED presence for the
|
|
# affected date flips: the override beats the Tuesday-absent pattern.
|
|
_patterns, overrides, engine = await _child_state(database, child_id)
|
|
assert [record.id for record in overrides] == [payload["id"]]
|
|
assert engine.is_present(child_id, TUESDAY) is True
|
|
# A date the override does not cover keeps the pattern's answer.
|
|
assert engine.is_present(child_id, ANCHOR_MONDAY) is True
|
|
|
|
# Delete: the row is gone and the resolved presence follows the
|
|
# pattern again.
|
|
deleted = await client.delete(
|
|
f"/api/v1/admin/presence-overrides/{payload['id']}",
|
|
headers=_admin_headers(),
|
|
)
|
|
assert deleted.status_code == 200
|
|
assert deleted.json() == {"status": "ok"}
|
|
assert (
|
|
await _dao_presence.PresenceOverridesDao(database).get(payload["id"])
|
|
is None
|
|
)
|
|
_patterns, overrides, engine = await _child_state(database, child_id)
|
|
assert overrides == []
|
|
assert engine.is_present(child_id, TUESDAY) is False
|
|
|
|
|
|
# --- error mapping: 404 vs 422 ----------------------------------------------
|
|
|
|
|
|
async def test_pattern_and_override_for_unknown_child_are_404(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""A presence write naming a child that does not exist is 404."""
|
|
client = admin_presence.client
|
|
|
|
pattern = await client.post(
|
|
_patterns_url(999),
|
|
json=_pattern_body(),
|
|
headers=_admin_headers(),
|
|
)
|
|
assert pattern.status_code == 404
|
|
assert pattern.json()["detail"] == "Child not found"
|
|
|
|
override = await client.post(
|
|
"/api/v1/admin/presence-overrides",
|
|
json=_override_body(999),
|
|
headers=_admin_headers(),
|
|
)
|
|
assert override.status_code == 404
|
|
assert override.json()["detail"] == "Child not found"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("body", "field"),
|
|
[
|
|
(_pattern_body(cycle_length_weeks=0), "cycle_length_weeks"),
|
|
(_pattern_body(cycle_length_weeks=5), "cycle_length_weeks"),
|
|
# Strict JSON integers only: no float or string coercion.
|
|
(_pattern_body(cycle_length_weeks=2.5), "cycle_length_weeks"),
|
|
(_pattern_body(cycle_length_weeks="2"), "cycle_length_weeks"),
|
|
(_pattern_body(cycle_length_weeks=1.0), "cycle_length_weeks"),
|
|
# week 1 of the cycle missing:
|
|
(_pattern_body(cycle_length_weeks=2, pattern={"0": [0]}), "pattern"),
|
|
(_pattern_body(pattern={}), "pattern"),
|
|
(_pattern_body(anchor_date="2026-13-40"), "anchor_date"),
|
|
(_pattern_body(anchor_date="05/01/2026"), "anchor_date"),
|
|
(_pattern_body(pattern={"0": [7]}), "pattern"), # weekday out of 0..6
|
|
# Strict JSON integer weekdays: no bool, string or float coercion.
|
|
(_pattern_body(pattern={"0": [True]}), "pattern"),
|
|
(_pattern_body(pattern={"0": [False]}), "pattern"),
|
|
(_pattern_body(pattern={"0": ["1"]}), "pattern"),
|
|
(_pattern_body(pattern={"0": [1.0]}), "pattern"),
|
|
(_pattern_body(pattern={"nope": [0]}), "pattern"), # non-int week
|
|
(_pattern_body(pattern={"0": "0,2,4"}), "pattern"), # not a list
|
|
(_pattern_body(kind="sometimes"), "kind"),
|
|
(_pattern_body(kind="HOME"), "kind"),
|
|
(_pattern_body(name=""), "name"),
|
|
(_pattern_body(name=" "), "name"),
|
|
],
|
|
)
|
|
async def test_rejected_pattern_is_422(
|
|
admin_presence: SimpleNamespace, body: dict[str, object], field: str
|
|
) -> None:
|
|
"""A rejected pattern is 422 naming the field, and stores nothing."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
response = await client.post(
|
|
_patterns_url(child_id),
|
|
json=body,
|
|
headers=_admin_headers(),
|
|
)
|
|
assert response.status_code == 422, response.text
|
|
assert _detail_names(response, field), response.json()
|
|
assert (
|
|
await _dao_presence.PresencePatternsDao(
|
|
admin_presence.database
|
|
).list_by_child(child_id)
|
|
== []
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize("missing", ["name", "kind"])
|
|
async def test_pattern_missing_required_field_is_422(
|
|
admin_presence: SimpleNamespace, missing: str
|
|
) -> None:
|
|
"""The new required fields cannot be omitted (an old schedule body)."""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
body = _pattern_body()
|
|
del body[missing]
|
|
response = await client.post(
|
|
_patterns_url(child_id), json=body, headers=_admin_headers()
|
|
)
|
|
assert response.status_code == 422
|
|
assert _detail_names(response, missing)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"body",
|
|
[
|
|
_override_body(1, start_date="2026-01-07", end_date="2026-01-06"),
|
|
_override_body(1, start_date="2026-02-30", end_date="2026-02-30"),
|
|
dict(_override_body(1), note=5),
|
|
dict(_override_body(1), child_id="one"),
|
|
],
|
|
)
|
|
async def test_rejected_override_is_422(
|
|
admin_presence: SimpleNamespace, body: dict[str, object]
|
|
) -> None:
|
|
"""A rejected override (inverted/malformed dates, bad note/id) is 422.
|
|
|
|
The shape failures (a non-string note, a non-integer child id) are
|
|
the body model's; the date failures are the PresenceOverride
|
|
model's. A string ``is_present`` like ``"yes"`` is deliberately
|
|
absent: Pydantic's lax bool COERCES it to ``True`` (the same design
|
|
as the children active route), so it never reaches the model's
|
|
real-bool check.
|
|
"""
|
|
response = await admin_presence.client.post(
|
|
"/api/v1/admin/presence-overrides", json=body, headers=_admin_headers()
|
|
)
|
|
assert response.status_code == 422
|
|
|
|
|
|
async def test_overlapping_override_is_422_and_first_survives(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""An override overlapping the child's existing one is 422.
|
|
|
|
The conflicting write persists nothing: the child's original
|
|
override survives unchanged.
|
|
"""
|
|
client = admin_presence.client
|
|
child_id = await _create_child(client)
|
|
created = await client.post(
|
|
"/api/v1/admin/presence-overrides",
|
|
json=_override_body(child_id),
|
|
headers=_admin_headers(),
|
|
)
|
|
assert created.status_code == 201
|
|
|
|
response = await client.post(
|
|
"/api/v1/admin/presence-overrides",
|
|
json=_override_body(child_id, is_present=False),
|
|
headers=_admin_headers(),
|
|
)
|
|
assert response.status_code == 422
|
|
_patterns, overrides, _engine = await _child_state(
|
|
admin_presence.database, child_id
|
|
)
|
|
assert [record.id for record in overrides] == [created.json()["id"]]
|
|
|
|
|
|
async def test_delete_unknown_override_is_404(
|
|
admin_presence: SimpleNamespace,
|
|
) -> None:
|
|
"""Deleting an override id that does not exist is 404."""
|
|
response = await admin_presence.client.delete(
|
|
"/api/v1/admin/presence-overrides/999", headers=_admin_headers()
|
|
)
|
|
assert response.status_code == 404
|
|
assert response.json()["detail"] == "Presence override not found"
|
|
|
|
malformed = await admin_presence.client.delete(
|
|
"/api/v1/admin/presence-overrides/not-an-id",
|
|
headers=_admin_headers(),
|
|
)
|
|
assert malformed.status_code == 422
|