Calendar reminders as push notifications

A job every minute finds the event reminders that fell due — repeating events
and moved occurrences expanded as the calendar view does — and pushes each
once to every device with notifications on (sdk.push, new: plugins can notify
through the new-mail push delivery). A reminder missed while the worker was down
is still sent within 10 minutes; cancelled events and declined invitations stay
quiet. Title, then "In 15 minutes, 14:00 · Room 2" in the user's zone and clock
format; it stays until dismissed and shows even with the app open; clicking it
opens that day (/p/calendar?date=…, new deep link).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

backend/tests/plugins/test_calendar_reminders.py

@@ -0,0 +1,130 @@
+"""Event reminders as notifications (calendar plugin, sdk.push): due reminders
+are sent once, repeating events remind on each occurrence, cancelled and
+declined ones stay quiet."""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import AsyncIterator
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import httpx
+import pytest
+import pytest_asyncio
+from httpx import ASGITransport
+from sqlalchemy import delete, text
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlalchemy.pool import NullPool
+from webmail_plugin_calendar import reminders  # type: ignore[import-not-found]
+
+from app.config import get_settings
+from app.identity.passwords import hash_password
+from app.identity.sessions import create_session
+from app.main import create_app
+from app.models import User
+from app.plugins.sdk import PluginPush
+
+CAL = "/api/plugins/calendar"
+# Far from any real event in the dev database.
+MON_9 = datetime(2031, 6, 2, 9, 0, tzinfo=UTC)  # a Monday
+
+
+@pytest_asyncio.fixture
+async def ctx(
+    monkeypatch: pytest.MonkeyPatch,
+) -> AsyncIterator[tuple[httpx.AsyncClient, uuid.UUID, list[dict[str, Any]], Any]]:
+    sent: list[dict[str, Any]] = []
+
+    async def fake_notify(self: PluginPush, user_id: uuid.UUID, **kw: Any) -> int:
+        sent.append({"user_id": user_id, **kw})
+        return 1
+
+    monkeypatch.setattr(PluginPush, "notify", fake_notify)
+    engine = create_async_engine(get_settings().database_url, poolclass=NullPool)
+    sm = async_sessionmaker(engine, expire_on_commit=False)
+    async with sm() as s:
+        user = User(
+            handle=f"rem{uuid.uuid4().hex[:8]}@test.local", password_hash=hash_password("pw")
+        )
+        s.add(user)
+        await s.commit()
+    token = await create_session(user.id, "pytest")
+    client = httpx.AsyncClient(
+        transport=ASGITransport(app=create_app()),
+        base_url="http://testserver",
+        cookies={"session": token, "csrf": "c"},
+        headers={"X-CSRF": "c"},
+    )
+    try:
+        yield client, user.id, sent, sm
+    finally:
+        await client.aclose()
+        async with sm() as s:
+            await s.execute(
+                text("DELETE FROM plg_calendar_calendars WHERE user_id = :u"), {"u": str(user.id)}
+            )
+            await s.execute(text("DELETE FROM plugin_kv WHERE user_id = :u"), {"u": str(user.id)})
+            await s.execute(delete(User).where(User.id == user.id))
+            await s.commit()
+        await engine.dispose()
+
+
+async def _event(client: httpx.AsyncClient, **fields: Any) -> str:
+    cal = (await client.get(f"{CAL}/calendars")).json()[0]["id"]
+    r = await client.post(f"{CAL}/events", json={"calendar_id": cal, **fields})
+    assert r.status_code == 200, r.text
+    return str(r.json()["id"])
+
+
+async def test_due_reminders_are_sent_once(ctx) -> None:  # type: ignore[no-untyped-def]
+    client, user_id, sent, sm = ctx
+    await _event(
+        client,
+        summary="Dentist",
+        location="Main St 4",
+        dtstart=MON_9.isoformat(),
+        dtend=(MON_9 + timedelta(hours=1)).isoformat(),
+        reminders=[10, 60],
+    )
+    called_off = await _event(
+        client, summary="Called off", dtstart=MON_9.isoformat(), reminders=[10]
+    )
+    async with sm() as db:  # cancelled by its organizer: never reminds
+        await db.execute(
+            text("UPDATE plg_calendar_events SET status = 'cancelled' WHERE id = :id"),
+            {"id": called_off},
+        )
+        await db.commit()
+
+    async def run(at: datetime) -> int:
+        return await reminders.reminder_job({}, now=at, only_user=user_id)
+
+    assert await run(MON_9 - timedelta(minutes=61)) == 0  # nothing due yet
+    assert await run(MON_9 - timedelta(minutes=60)) == 1  # the 1-hour reminder
+    assert sent[-1]["title"] == "Dentist"
+    assert sent[-1]["body"] == "In 1 hour, 09:00 · Main St 4"
+    assert sent[-1]["url"] == "/p/calendar?date=2031-06-02" and sent[-1]["sticky"] is True
+    assert await run(MON_9 - timedelta(minutes=59)) == 0  # not again
+    # The worker was down when the 10-minute reminder came due: sent late, once.
+    assert await run(MON_9 - timedelta(minutes=4)) == 1
+    assert sent[-1]["body"] == "In 10 minutes, 09:00 · Main St 4"
+    assert await run(MON_9 - timedelta(minutes=3)) == 0
+    assert len(sent) == 2
+
+
+async def test_repeating_events_remind_on_each_occurrence(ctx) -> None:  # type: ignore[no-untyped-def]
+    client, user_id, sent, _ = ctx
+    await _event(
+        client,
+        summary="Weekly sync",
+        dtstart=MON_9.isoformat(),
+        dtend=(MON_9 + timedelta(minutes=30)).isoformat(),
+        rrule="FREQ=WEEKLY;BYDAY=MO",
+        reminders=[15],
+    )
+    for week in range(3):
+        at = MON_9 + timedelta(weeks=week) - timedelta(minutes=15)
+        assert await reminders.reminder_job({}, now=at, only_user=user_id) == 1
+    tags = {s["tag"] for s in sent}
+    assert len(sent) == 3 and len(tags) == 3  # one notification per occurrence