Anlegget
@@ -138,7 +160,7 @@
const $ = s => document.querySelector(s);
const text = $('#text'), voice = $('#voice'), speed = $('#speed'), chime = $('#chime');
const msg = $('#msg'), audio = $('#player'), btnPreview = $('#btnPreview'), btnAnnounce = $('#btnAnnounce');
-let cfg = {}, can = [], previewedKey = null, pollTimer = null;
+let cfg = {}, can = [], previewedKey = null, pollTimer = null, me = null, skew = 0;
function key() { return JSON.stringify(payload()); }
function payload() {
@@ -161,6 +183,44 @@ function updateAnnounce() {
(btnAnnounce.disabled ? 'Forhåndslytt først' : '');
btnPreview.disabled = !may('preview');
btnPreview.title = may('preview') ? '' : 'Du har ikke lov til å forhåndslytte';
+
+ // Planlegging er låst til forhåndslytten på samme måte som «Send ut»:
+ // ingen skal legge noe i kalenderen de ikke har hørt.
+ const at = $('#at').value;
+ $('#whenbox').classList.toggle('hidden', !may('schedule'));
+ $('#btnSchedule').disabled = !ready || !at || !may('schedule');
+ $('#btnSchedule').title = !at ? 'Velg tidspunkt' :
+ (!ready ? 'Forhåndslytt først' : '');
+}
+
+// Serverens klokke gjelder. Containeren kan stå i UTC mens nettleseren står
+// i CEST, og da ville «om 20 minutter» blitt to timer feil.
+function serverNow() { return Date.now() / 1000 + skew; }
+
+function atEpoch() {
+ const v = $('#at').value;
+ if (!v) return null;
+ const t = new Date(v).getTime(); // datetime-local tolkes lokalt
+ return Number.isFinite(t) ? t / 1000 : null;
+}
+
+function omTid(ts) {
+ const s = ts - serverNow();
+ if (s < 0) return 'nå';
+ if (s < 90) return 'om ' + Math.round(s) + ' s';
+ if (s < 5400) return 'om ' + Math.round(s / 60) + ' min';
+ if (s < 86400) return 'om ' + (s / 3600).toFixed(1).replace('.0', '') + ' t';
+ return 'om ' + Math.round(s / 86400) + ' d';
+}
+
+function setAtIn(minutes) {
+ const d = new Date(Date.now() + minutes * 60000);
+ d.setSeconds(0, 0);
+ // datetime-local vil ha lokal tid uten sone, ikke ISO i UTC.
+ const pad = v => String(v).padStart(2, '0');
+ $('#at').value = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
+ + `T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+ updateAnnounce();
}
async function req(path, opts) {
@@ -250,6 +310,7 @@ function applyAuth(auth) {
if (!$('#pin').value) $('#pin').value = localStorage.getItem('pin') || '';
}
+ me = auth.user;
$('#btnStop').classList.toggle('hidden', !may('stop'));
$('#btnClear').classList.toggle('hidden', !may('clear'));
updateAnnounce();
@@ -281,10 +342,42 @@ async function init() {
if (!chime.value) chime.value = c.default_chime;
applyAuth(c.auth || {});
+ $('#atquick').replaceChildren(...[
+ ['+5 min', 5], ['+15 min', 15], ['+1 t', 60], ['+3 t', 180],
+ ].map(([label, min]) => {
+ const b = document.createElement('button');
+ b.textContent = label; b.onclick = () => setAtIn(min);
+ return b;
+ }));
poll();
pollTimer = setInterval(poll, 2000);
}
+$('#at').addEventListener('input', updateAnnounce);
+
+$('#btnSchedule').addEventListener('click', async () => {
+ const at = atEpoch();
+ if (!at) return say('Velg et tidspunkt først.', 'err');
+ if (at < serverNow()) return say('Tidspunktet er passert.', 'err');
+ $('#btnSchedule').disabled = true;
+ try {
+ const item = await (await api('/api/schedule', { ...payload(), at })).json();
+ say(`Planlagt ${new Date(item.at * 1000).toLocaleString('no', {
+ weekday: 'short', hour: '2-digit', minute: '2-digit' })}.`, 'ok');
+ text.value = ''; text.dispatchEvent(new Event('input')); previewedKey = null;
+ $('#at').value = '';
+ audio.pause(); audio.classList.remove('show');
+ poll();
+ } catch (e) { onError(e); }
+ finally { updateAnnounce(); }
+});
+
+async function cancelSched(id, what) {
+ if (!confirm(`Avbryte den planlagte meldingen?\n\n${what}`)) return;
+ try { await api('/api/schedule/cancel', { id }); say('Avbrutt.', 'ok'); poll(); }
+ catch (e) { onError(e); }
+}
+
let pinDebounce = null;
$('#pin').addEventListener('input', e => {
localStorage.setItem('pin', e.target.value);
@@ -341,10 +434,40 @@ function li(it) {
l.querySelector('.s').textContent = (STATUS[it.status] || it.status) + (it.error ? ' · ' + it.error : '');
return l;
}
+const SCHED_STATUS = { sent: 'sendt', missed: 'gikk glipp av', cancelled: 'avbrutt' };
+function schedLi(it) {
+ const l = document.createElement('li');
+ l.className = it.status;
+ l.innerHTML = '';
+ const when = new Date(it.at * 1000);
+ l.querySelector('.t').textContent = when.toLocaleTimeString('no', { hour: '2-digit', minute: '2-digit' });
+ l.querySelector('.x').textContent = it.text;
+ l.querySelector('.by').textContent = it.user || '';
+ const s = l.querySelector('.s');
+ if (it.status === 'pending') {
+ s.textContent = omTid(it.at) + ' ';
+ // Egne kan man alltid avbryte; andres krever samme rett som å tømme kø.
+ if (may('schedule') && (!me || !it.user || may('clear') || it.user === me.name)) {
+ const b = document.createElement('button');
+ b.className = 'x'; b.textContent = '✕'; b.title = 'Avbryt';
+ b.onclick = () => cancelSched(it.id, it.text);
+ s.append(b);
+ }
+ } else {
+ s.textContent = (SCHED_STATUS[it.status] || it.status) + (it.note ? ' · ' + it.note : '');
+ }
+ return l;
+}
+
async function poll() {
const now = $('#now');
try {
const s = await (await req('/api/status', { headers: headers(false) })).json();
+ if (s.now) skew = s.now - Date.now() / 1000;
+ const sc = s.scheduled || { pending: [], done: [] };
+ const rows = [...sc.pending, ...sc.done];
+ $('#schedcard').classList.toggle('hidden', rows.length === 0);
+ $('#sched').replaceChildren(...rows.map(schedLi));
if (s.current) { now.className = 'now'; now.innerHTML = ''; now.append(document.createTextNode(s.current.text)); }
else { now.className = 'now idle'; now.textContent = (cfg.app && cfg.app.idle_text) || ''; }
$('#queue').replaceChildren(...s.queued.map(li));
diff --git a/install.sh b/install.sh
index e006e49..2f7aed7 100755
--- a/install.sh
+++ b/install.sh
@@ -84,6 +84,7 @@ PUID=$(id -u)
PGID=$(id -g)
XDG_RUNTIME_DIR=${XDG_RUNTIME_DIR:-/run/user/$(id -u)}
BIND_IP=$BIND_IP
+TZ=$(timedatectl show -p Timezone --value 2>/dev/null || cat /etc/timezone 2>/dev/null || echo Europe/Oslo)
ANNOUNCER_PORT=${ANNOUNCER_PORT:-8090}
ANNOUNCER_SINK=${ANNOUNCER_SINK:-}
ANNOUNCER_TITLE=${ANNOUNCER_TITLE:-}
diff --git a/schedule.py b/schedule.py
new file mode 100644
index 0000000..04dbcea
--- /dev/null
+++ b/schedule.py
@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Planlagte sendinger: «send denne kl. 18:00».
+
+Dette er den første delen av appen som *må* ligge på disk. Kø og historikk
+har alltid bare levd i minnet, og det har gått bra fordi en melding spilles
+med en gang. En melding planlagt til 18:00 må overleve at containeren
+startes om 17:45, så den lagres i en JSON-fil som skrives atomisk.
+
+Ingen database. Dette er en håndfull meldinger på et arrangement, og en fil
+man kan lese med `cat` er verdt mer her enn indekser.
+
+Modulen vet ingenting om Flask eller om avspilling. Den lagrer, og den svarer
+på «hva skal sendes nå?». announcer.py eier tråden som spør.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import secrets
+import threading
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+log = logging.getLogger("announcer.schedule")
+
+# Hvor lenge etter planlagt tid vi fortsatt sender. Dette er slingringsmonn
+# for at tråden våkner med noen sekunders mellomrom og for en kjapp omstart –
+# ikke en policy om å ta igjen etterslep. Var maskina av en time, skal
+# «turneringen starter om ti minutter» ikke ut på anlegget.
+DEFAULT_GRACE = 120.0
+
+# Hvor langt fram man får planlegge. Fanger opp tastefeil i årstall.
+DEFAULT_MAX_AHEAD = 30 * 86400.0
+
+# Hvor mange ferdige (sendt/hoppet over/avbrutt) vi beholder for visning.
+KEEP_DONE = 50
+
+STATUSES = ("pending", "sent", "missed", "cancelled")
+
+
+@dataclass
+class Scheduled:
+ id: str
+ at: float # epoch, absolutt – derfor ingen tidssone
+ text: str
+ voice: str
+ speed: float
+ chime: str
+ user: str = ""
+ subject: str = ""
+ method: str = "none"
+ created: float = field(default_factory=time.time)
+ status: str = "pending" # pending | sent | missed | cancelled
+ note: str = ""
+
+ def public(self) -> dict:
+ d = asdict(self)
+ d.pop("subject", None)
+ return d
+
+
+class Schedule:
+ """Trådsikker liste av planlagte meldinger, lagret i én JSON-fil."""
+
+ def __init__(self, path: Path, *, grace: float = DEFAULT_GRACE,
+ max_ahead: float = DEFAULT_MAX_AHEAD) -> None:
+ self.path = Path(path)
+ self.grace = float(grace)
+ self.max_ahead = float(max_ahead)
+ self._lock = threading.Lock()
+ self.items: list[Scheduled] = []
+ self._load()
+
+ # -- disk --------------------------------------------------------------
+ def _load(self) -> None:
+ if not self.path.is_file():
+ return
+ try:
+ raw = json.loads(self.path.read_text(encoding="utf-8"))
+ except (OSError, ValueError) as e:
+ # En ødelagt fil skal ikke hindre appen fra å starte; da er det
+ # bedre å miste planene og si det i loggen.
+ log.warning("kunne ikke lese %s (%s) – starter med tom liste", self.path, e)
+ return
+ known = {f for f in Scheduled.__dataclass_fields__}
+ for entry in raw.get("items", []):
+ if not isinstance(entry, dict):
+ continue
+ try:
+ self.items.append(Scheduled(**{k: v for k, v in entry.items() if k in known}))
+ except TypeError as e:
+ log.warning("hopper over ugyldig oppføring (%s)", e)
+ log.info("leste %d planlagte sendinger fra %s", len(self.items), self.path)
+
+ def _save(self) -> None:
+ """Skriv til side og flytt på plass, så fila aldri er halvskrevet."""
+ try:
+ self.path.parent.mkdir(parents=True, exist_ok=True)
+ tmp = self.path.with_suffix(".tmp")
+ tmp.write_text(
+ json.dumps({"items": [asdict(i) for i in self.items]},
+ ensure_ascii=False, indent=1),
+ encoding="utf-8",
+ )
+ tmp.replace(self.path)
+ except OSError as e:
+ log.error("fikk ikke lagret %s: %s", self.path, e)
+
+ def _trim(self) -> None:
+ done = [i for i in self.items if i.status != "pending"]
+ if len(done) > KEEP_DONE:
+ drop = {id(i) for i in sorted(done, key=lambda i: i.at)[:len(done) - KEEP_DONE]}
+ self.items = [i for i in self.items if id(i) not in drop]
+
+ # -- endringer ---------------------------------------------------------
+ def add(self, *, at: float, text: str, voice: str, speed: float, chime: str,
+ user: str = "", subject: str = "", method: str = "none") -> Scheduled:
+ """Legger til en melding. Kaster ValueError på et ubrukelig tidspunkt."""
+ at = float(at)
+ now = time.time()
+ if at < now - self.grace:
+ raise ValueError("Tidspunktet er passert")
+ if at > now + self.max_ahead:
+ raise ValueError(f"Mer enn {int(self.max_ahead / 86400)} dager fram i tid")
+ item = Scheduled(
+ id=secrets.token_hex(4), at=at, text=text, voice=voice, speed=speed,
+ chime=chime, user=user, subject=subject, method=method,
+ )
+ with self._lock:
+ self.items.append(item)
+ self._trim()
+ self._save()
+ return item
+
+ def cancel(self, sched_id: str) -> Scheduled | None:
+ with self._lock:
+ for i in self.items:
+ if i.id == sched_id and i.status == "pending":
+ i.status = "cancelled"
+ self._trim()
+ self._save()
+ return i
+ return None
+
+ def get(self, sched_id: str) -> Scheduled | None:
+ with self._lock:
+ return next((i for i in self.items if i.id == sched_id), None)
+
+ def mark(self, sched_id: str, status: str, note: str = "") -> None:
+ assert status in STATUSES, status
+ with self._lock:
+ for i in self.items:
+ if i.id == sched_id:
+ i.status = status
+ i.note = note
+ # Også her, ikke bare i add(): ellers vokser lista av
+ # ferdige ubegrenset så lenge ingen legger til noe nytt.
+ self._trim()
+ self._save()
+ return
+
+ # -- oppslag -----------------------------------------------------------
+ def due(self, now: float | None = None) -> tuple[list[Scheduled], list[Scheduled]]:
+ """Returnerer (skal sendes nå, for sent – hopp over).
+
+ Kaller ikke _save(); announcer.py markerer dem etterpå, så en melding
+ ikke kan bli stående som «sendt» uten at den faktisk ble lagt i kø.
+ """
+ now = time.time() if now is None else now
+ send: list[Scheduled] = []
+ missed: list[Scheduled] = []
+ with self._lock:
+ for i in self.items:
+ if i.status != "pending" or i.at > now:
+ continue
+ (send if now - i.at <= self.grace else missed).append(i)
+ return send, missed
+
+ def snapshot(self) -> dict:
+ with self._lock:
+ pending = sorted((i for i in self.items if i.status == "pending"),
+ key=lambda i: i.at)
+ done = sorted((i for i in self.items if i.status != "pending"),
+ key=lambda i: i.at, reverse=True)[:15]
+ return {
+ "pending": [i.public() for i in pending],
+ "done": [i.public() for i in done],
+ }
diff --git a/tests/test_auth.py b/tests/test_auth.py
index 199974a..6ffef76 100644
--- a/tests/test_auth.py
+++ b/tests/test_auth.py
@@ -358,12 +358,13 @@ def test_nestet_claim_hentes():
def test_rolle_til_handling():
cfg = config.load("/finnes-ikke.toml")
assert cfg.permissions(("admin",)) == frozenset(config.ACTIONS)
- assert cfg.permissions(("crew",)) == frozenset({"view", "preview", "announce"})
+ assert cfg.permissions(("crew",)) == frozenset({"view", "preview", "announce", "schedule"})
assert cfg.permissions(("ukjent-rolle",)) == frozenset()
assert cfg.permissions(()) == frozenset()
# Roller legges sammen
cfg.data["roles"]["bare_stopp"] = ["stop"]
- assert cfg.permissions(("crew", "bare_stopp")) == frozenset({"view", "preview", "announce", "stop"})
+ assert cfg.permissions(("crew", "bare_stopp")) == frozenset(
+ {"view", "preview", "announce", "schedule", "stop"})
def test_ukjente_handlinger_i_roles_ignoreres():
diff --git a/tests/test_schedule.py b/tests/test_schedule.py
new file mode 100644
index 0000000..3890d92
--- /dev/null
+++ b/tests/test_schedule.py
@@ -0,0 +1,235 @@
+"""Tester for planlagte sendinger.
+
+Det som er verdt å prøve her er ikke at en melding kan legges i en liste, men
+de to tingene som faktisk kan svikte: at lista overlever en omstart, og at en
+melding som skulle gått for en time siden *ikke* spilles når maskina kommer
+tilbake.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import schedule as sched # noqa: E402
+
+
+def mk(tmp_path: Path, **kw) -> sched.Schedule:
+ return sched.Schedule(tmp_path / "scheduled.json", **kw)
+
+
+def add(s: sched.Schedule, *, om: float = 3600, text: str = "melding", **kw):
+ """Legger til en melding «om» så mange sekunder."""
+ return s.add(at=time.time() + om, text=text, voice="finn", speed=1.0,
+ chime="none", **kw)
+
+
+# --------------------------------------------------------------------------
+# Lagring – grunnen til at modulen finnes
+# --------------------------------------------------------------------------
+
+
+def test_planen_overlever_omstart(tmp_path):
+ s = mk(tmp_path)
+ item = add(s, om=1800, text="Pizzaen kommer", user="Kari", subject="jwt:7")
+ # Ny instans, som etter en restart av containeren
+ s2 = mk(tmp_path)
+ assert len(s2.items) == 1
+ got = s2.items[0]
+ assert (got.id, got.text, got.user, got.subject) == (item.id, "Pizzaen kommer", "Kari", "jwt:7")
+ assert got.status == "pending"
+
+
+def test_fila_er_lesbar_json(tmp_path):
+ """Poenget med fil framfor database: man skal kunne cat'e den."""
+ s = mk(tmp_path)
+ add(s, text="Hallo")
+ raw = json.loads((tmp_path / "scheduled.json").read_text())
+ assert raw["items"][0]["text"] == "Hallo"
+
+
+def test_ingen_tmp_fil_ligger_igjen(tmp_path):
+ s = mk(tmp_path)
+ add(s)
+ assert not list(tmp_path.glob("*.tmp")), "atomisk skriving skal rydde etter seg"
+
+
+def test_odelagt_fil_hindrer_ikke_oppstart(tmp_path):
+ (tmp_path / "scheduled.json").write_text("{dette er ikke json")
+ s = mk(tmp_path) # skal ikke kaste
+ assert s.items == []
+ add(s, text="virker likevel")
+ assert len(mk(tmp_path).items) == 1
+
+
+def test_ukjente_felt_i_fila_ignoreres(tmp_path):
+ """Så en nyere versjon av fila ikke velter en eldre app."""
+ (tmp_path / "scheduled.json").write_text(json.dumps({"items": [{
+ "id": "abc", "at": time.time() + 60, "text": "x", "voice": "finn",
+ "speed": 1.0, "chime": "none", "noe_nytt": 42,
+ }]}))
+ s = mk(tmp_path)
+ assert len(s.items) == 1 and s.items[0].id == "abc"
+
+
+def test_tom_mappe_er_greit(tmp_path):
+ s = mk(tmp_path / "finnes" / "ikke" / "enda")
+ add(s)
+ assert len(s.items) == 1
+
+
+# --------------------------------------------------------------------------
+# Validering
+# --------------------------------------------------------------------------
+
+
+def test_tidspunkt_i_fortiden_avvises(tmp_path):
+ s = mk(tmp_path)
+ with pytest.raises(ValueError, match="passert"):
+ add(s, om=-3600)
+
+
+def test_tidspunkt_rett_bak_oss_godtas(tmp_path):
+ """Innenfor nådefristen; ellers ville «send nå» vært en kappløpssituasjon."""
+ s = mk(tmp_path, grace=120)
+ assert add(s, om=-30) is not None
+
+
+def test_for_langt_fram_avvises(tmp_path):
+ s = mk(tmp_path, max_ahead=30 * 86400)
+ with pytest.raises(ValueError, match="dager"):
+ add(s, om=400 * 86400) # typisk tastefeil i årstall
+
+
+# --------------------------------------------------------------------------
+# due(): skal den sendes, eller gikk den glipp av?
+# --------------------------------------------------------------------------
+
+
+def test_ikke_forfalt_blir_liggende(tmp_path):
+ s = mk(tmp_path)
+ add(s, om=600)
+ send, missed = s.due()
+ assert (send, missed) == ([], [])
+
+
+def test_forfalt_innenfor_nadefrist_sendes(tmp_path):
+ s = mk(tmp_path, grace=120)
+ item = add(s, om=600)
+ # Som om klokka har gått fram til litt etter planlagt tid.
+ send, missed = s.due(now=item.at + 30)
+ assert [i.id for i in send] == [item.id]
+ assert missed == []
+
+
+def test_for_sent_gar_glipp_av_og_spilles_ikke(tmp_path):
+ """Kjernen i det Kent valgte: hopp over, men vis det.
+
+ Forløpet er: meldingen ble lagt inn i god tid, maskina var av da den
+ skulle gått, og nå er den tilbake en time for sent. «Turneringen starter
+ om ti minutter» skal ikke ut på anlegget da."""
+ s = mk(tmp_path, grace=120)
+ item = add(s, om=600)
+ send, missed = s.due(now=item.at + 3600)
+ assert send == []
+ assert [i.id for i in missed] == [item.id]
+
+
+def test_due_endrer_ingenting_selv(tmp_path):
+ """announcer.py markerer først etter at meldingen faktisk er i kø, så en
+ melding ikke kan stå som «sendt» uten å ha blitt det."""
+ s = mk(tmp_path)
+ item = add(s, om=600)
+ s.due(now=item.at + 10)
+ assert mk(tmp_path).items[0].status == "pending"
+
+
+def test_avbrutt_forfaller_ikke(tmp_path):
+ s = mk(tmp_path)
+ item = add(s, om=600)
+ s.cancel(item.id)
+ assert s.due(now=item.at + 10) == ([], [])
+
+
+def test_sendt_forfaller_ikke_igjen(tmp_path):
+ s = mk(tmp_path)
+ item = add(s, om=600)
+ s.mark(item.id, "sent", "kø #4")
+ assert s.due(now=item.at + 10) == ([], [])
+
+
+# --------------------------------------------------------------------------
+# Avbryting og markering
+# --------------------------------------------------------------------------
+
+
+def test_avbryting_lagres(tmp_path):
+ s = mk(tmp_path)
+ item = add(s)
+ assert s.cancel(item.id) is not None
+ assert mk(tmp_path).items[0].status == "cancelled"
+
+
+def test_avbryting_to_ganger_gir_none(tmp_path):
+ s = mk(tmp_path)
+ item = add(s)
+ s.cancel(item.id)
+ assert s.cancel(item.id) is None
+
+
+def test_avbryting_av_ukjent_id_gir_none(tmp_path):
+ assert mk(tmp_path).cancel("finnes-ikke") is None
+
+
+def test_mark_lagres(tmp_path):
+ s = mk(tmp_path)
+ item = add(s)
+ s.mark(item.id, "missed", "maskina var av")
+ got = mk(tmp_path).items[0]
+ assert (got.status, got.note) == ("missed", "maskina var av")
+
+
+# --------------------------------------------------------------------------
+# Visning
+# --------------------------------------------------------------------------
+
+
+def test_snapshot_sorterer_ventende_kronologisk(tmp_path):
+ s = mk(tmp_path)
+ add(s, om=7200, text="sist")
+ add(s, om=600, text="først")
+ add(s, om=3600, text="midt")
+ assert [i["text"] for i in s.snapshot()["pending"]] == ["først", "midt", "sist"]
+
+
+def test_snapshot_skiller_ventende_fra_ferdige(tmp_path):
+ s = mk(tmp_path)
+ a = add(s, om=600, text="venter")
+ add(s, om=1200, text="venter også")
+ s.mark(a.id, "sent")
+ snap = s.snapshot()
+ assert [i["text"] for i in snap["pending"]] == ["venter også"]
+ assert [i["text"] for i in snap["done"]] == ["venter"]
+
+
+def test_subject_lekker_ikke_ut_til_klienten(tmp_path):
+ """Navnet skal vises, bruker-id-en er intern."""
+ s = mk(tmp_path)
+ add(s, user="Kari", subject="jwt:7")
+ pub = s.snapshot()["pending"][0]
+ assert pub["user"] == "Kari"
+ assert "subject" not in pub
+
+
+def test_ferdige_hoper_seg_ikke_opp(tmp_path):
+ s = mk(tmp_path)
+ for i in range(sched.KEEP_DONE + 20):
+ item = add(s, om=600 + i, text=f"nr {i}")
+ s.mark(item.id, "sent")
+ assert len([i for i in s.items if i.status != "pending"]) == sched.KEEP_DONE