15d7f5e873
- notescraft-lint (rules, safe fixes, learned style) and notescraft-blocks (block model and edits); engine lint.* and block.* commands with CLI and MCP parity - Lint tab, underlines, slash menu with preview in Source and Visual, block grip and menu, Settings > Editor and lint, Vim block keys - Visual view: tables, note embeds, %% comments, wrapping property chips - Vault knowledge (Related tab, assistant sources, Settings) and calendar plugin - Sidebar top padding fixed, dot grid follows PaperCraft spacing, right-card tabs no longer cover the collapse button Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
184 lines
8.2 KiB
Rust
184 lines
8.2 KiB
Rust
//! Reminders with an injected clock.
|
|
#![allow(clippy::unwrap_used, clippy::assert_is_empty)]
|
|
|
|
use notescraft_calendar::{
|
|
Alert, Item, Kind, Notifier, ReminderSettings, ReminderState, Status, alerts_for, catch_up, deliver, dismiss, epoch_minutes, inbox, snooze, tick,
|
|
};
|
|
|
|
fn at(text: &str) -> i64 {
|
|
epoch_minutes(text.parse().unwrap()).unwrap()
|
|
}
|
|
|
|
fn event(id: &str, start: &str, reminders: &[u32]) -> Item {
|
|
Item {
|
|
id: id.to_owned(),
|
|
kind: Kind::Event,
|
|
title: id.to_owned(),
|
|
start: start.parse().unwrap(),
|
|
end: None,
|
|
calendar: None,
|
|
tags: vec![],
|
|
priority: None,
|
|
status: None,
|
|
has_reminder: !reminders.is_empty(),
|
|
reminders: reminders.to_vec(),
|
|
note: None,
|
|
created: None,
|
|
done: false,
|
|
repeats: false,
|
|
source: None,
|
|
tz: None,
|
|
}
|
|
}
|
|
|
|
fn keys(alerts: &[Alert]) -> Vec<&str> {
|
|
alerts.iter().map(|alert| alert.item_id.as_str()).collect()
|
|
}
|
|
|
|
fn fresh(now: &str) -> ReminderState {
|
|
ReminderState { last_seen: Some(at(now)), ..ReminderState::default() }
|
|
}
|
|
|
|
#[test]
|
|
fn an_alert_fires_once_at_its_time() {
|
|
let items = [event("standup", "2026-10-20T09:30", &[10])];
|
|
let settings = ReminderSettings::default();
|
|
let mut state = fresh("2026-10-20T09:00");
|
|
assert!(tick(&items, at("2026-10-20T09:19"), &settings, &mut state).notify.is_empty(), "not yet");
|
|
let fired = tick(&items, at("2026-10-20T09:20"), &settings, &mut state);
|
|
assert_eq!(keys(&fired.notify), ["standup"]);
|
|
assert_eq!(fired.notify[0].minutes_before, 10);
|
|
assert!(tick(&items, at("2026-10-20T09:21"), &settings, &mut state).notify.is_empty(), "never twice");
|
|
assert!(tick(&items, at("2026-10-20T10:00"), &settings, &mut state).notify.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn several_reminders_and_defaults() {
|
|
let items = [event("a", "2026-10-20T10:00", &[60, 5]), event("b", "2026-10-20T10:00", &[])];
|
|
let settings = ReminderSettings { default_minutes: vec![15], ..ReminderSettings::default() };
|
|
let all = alerts_for(&items, &settings);
|
|
assert_eq!(all.iter().map(|alert| (alert.item_id.as_str(), alert.minutes_before)).collect::<Vec<_>>(), [("a", 60), ("b", 15), ("a", 5)]);
|
|
let none = alerts_for(&items, &ReminderSettings::default());
|
|
assert_eq!(none.len(), 2, "no default means an event with no reminder stays quiet");
|
|
}
|
|
|
|
#[test]
|
|
fn whole_day_tasks_and_cancelled_events_never_alert() {
|
|
let mut task = event("task", "2026-10-20T09:00", &[10]);
|
|
task.kind = Kind::Task;
|
|
let mut cancelled = event("cancelled", "2026-10-20T09:00", &[10]);
|
|
cancelled.status = Some(Status::Cancelled);
|
|
let all_day = event("all-day", "2026-10-20", &[10]);
|
|
assert!(alerts_for(&[task, cancelled, all_day], &ReminderSettings::default()).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn snoozing_brings_it_back_once_and_dismissing_ends_it() {
|
|
let items = [event("standup", "2026-10-20T09:30", &[10])];
|
|
let settings = ReminderSettings::default();
|
|
let mut state = fresh("2026-10-20T09:00");
|
|
let alert = tick(&items, at("2026-10-20T09:20"), &settings, &mut state).notify.remove(0);
|
|
snooze(&mut state, &alert.key, at("2026-10-20T09:20"), 5);
|
|
assert!(tick(&items, at("2026-10-20T09:24"), &settings, &mut state).notify.is_empty());
|
|
assert_eq!(inbox(&items, at("2026-10-20T09:24"), &settings, &state).snoozed.len(), 1);
|
|
let back = tick(&items, at("2026-10-20T09:25"), &settings, &mut state);
|
|
assert_eq!(keys(&back.notify), ["standup"]);
|
|
assert!(tick(&items, at("2026-10-20T09:26"), &settings, &mut state).notify.is_empty(), "it comes back once");
|
|
snooze(&mut state, &alert.key, at("2026-10-20T09:26"), 5);
|
|
dismiss(&mut state, &alert.key);
|
|
assert!(tick(&items, at("2026-10-20T09:40"), &settings, &mut state).notify.is_empty(), "dismissed means gone");
|
|
assert_eq!(inbox(&items, at("2026-10-20T09:40"), &settings, &state), notescraft_calendar::Inbox::default());
|
|
}
|
|
|
|
#[test]
|
|
fn quiet_hours_keep_the_inbox_but_not_the_sound() {
|
|
let items = [event("late", "2026-10-20T23:30", &[10]), event("early", "2026-10-21T06:30", &[10])];
|
|
let settings = ReminderSettings { quiet: Some((22 * 60, 7 * 60)), ..ReminderSettings::default() };
|
|
let mut state = fresh("2026-10-20T23:00");
|
|
let first = tick(&items, at("2026-10-20T23:20"), &settings, &mut state);
|
|
assert!(first.notify.is_empty());
|
|
assert_eq!(keys(&first.quiet), ["late"]);
|
|
let second = tick(&items, at("2026-10-21T06:20"), &settings, &mut state);
|
|
assert_eq!(keys(&second.quiet), ["early"], "the window wraps past midnight");
|
|
let shown = inbox(&items, at("2026-10-21T06:25"), &settings, &state);
|
|
assert_eq!(keys(&shown.due), ["early"], "a quiet alert is still waiting in the inbox");
|
|
let day = ReminderSettings { quiet: Some((9 * 60, 17 * 60)), ..ReminderSettings::default() };
|
|
let mut state = fresh("2026-10-21T08:00");
|
|
assert_eq!(
|
|
keys(&tick(&[event("noon", "2026-10-21T12:10", &[10])], at("2026-10-21T12:00"), &day, &mut state).quiet),
|
|
["noon"],
|
|
"a daytime window works too"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn what_fired_while_the_app_was_closed_is_missed_not_notified() {
|
|
let items = [event("one", "2026-10-20T09:30", &[10]), event("two", "2026-10-20T20:00", &[10]), event("old", "2026-10-19T09:30", &[10])];
|
|
let settings = ReminderSettings::default();
|
|
let mut state = fresh("2026-10-20T09:00");
|
|
let missed = catch_up(&items, at("2026-10-20T12:00"), &settings, &mut state);
|
|
assert_eq!(keys(&missed), ["one"], "only what fell between the last run and now");
|
|
assert_eq!(state.last_seen, Some(at("2026-10-20T12:00")));
|
|
assert!(tick(&items, at("2026-10-20T12:05"), &settings, &mut state).notify.is_empty(), "a missed alert is not re-notified as new");
|
|
let shown = inbox(&items, at("2026-10-20T12:05"), &settings, &state);
|
|
assert_eq!((keys(&shown.missed), keys(&shown.upcoming)), (vec!["one"], vec!["two"]));
|
|
assert!(shown.due.is_empty());
|
|
let mut empty = ReminderState::default();
|
|
assert!(catch_up(&items, at("2026-10-20T12:00"), &settings, &mut empty).is_empty(), "a first run has nothing to miss");
|
|
assert_eq!(empty.last_seen, Some(at("2026-10-20T12:00")));
|
|
}
|
|
|
|
#[test]
|
|
fn state_survives_json_and_the_clock_math_is_right() {
|
|
let items = [event("standup", "2026-10-20T09:30", &[10])];
|
|
let settings = ReminderSettings::default();
|
|
let mut state = fresh("2026-10-20T09:00");
|
|
tick(&items, at("2026-10-20T09:20"), &settings, &mut state);
|
|
snooze(&mut state, "x|y|1", 5, 5);
|
|
let again: ReminderState = serde_json::from_str(&serde_json::to_string(&state).unwrap()).unwrap();
|
|
assert_eq!(again, state);
|
|
assert_eq!(at("1970-01-02T00:01") - at("1970-01-01T00:00"), 1441);
|
|
assert_eq!(at("2027-01-01") - at("2026-12-31"), 1440);
|
|
assert_eq!(serde_json::from_str::<ReminderState>("{}").unwrap(), ReminderState::default());
|
|
}
|
|
|
|
struct Recorder {
|
|
seen: Vec<String>,
|
|
fail: bool,
|
|
}
|
|
|
|
impl Notifier for Recorder {
|
|
fn notify(&mut self, alert: &Alert) -> Result<(), String> {
|
|
if self.fail {
|
|
return Err(format!("no permission for {}", alert.item_id));
|
|
}
|
|
self.seen.push(alert.title.clone());
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn delivery_reports_what_the_notifier_refused() {
|
|
let items = [event("a", "2026-10-20T09:30", &[10]), event("b", "2026-10-20T09:30", &[10])];
|
|
let mut state = fresh("2026-10-20T09:00");
|
|
let due = tick(&items, at("2026-10-20T09:20"), &ReminderSettings::default(), &mut state);
|
|
let mut ok = Recorder { seen: vec![], fail: false };
|
|
assert!(deliver(&mut ok, &due).is_empty());
|
|
assert_eq!(ok.seen, ["a", "b"]);
|
|
let mut refused = Recorder { seen: vec![], fail: true };
|
|
assert_eq!(deliver(&mut refused, &due).len(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn hostile_state_never_panics() {
|
|
let mut state = ReminderState { last_seen: Some(i64::MAX), ..ReminderState::default() };
|
|
state.snoozed.insert("k".to_owned(), i64::MIN);
|
|
let items = [event("a", "2026-10-20T09:30", &[u32::MAX])];
|
|
let settings = ReminderSettings { quiet: Some((u32::MAX, 0)), default_minutes: vec![u32::MAX] };
|
|
let _ = tick(&items, 0, &settings, &mut state);
|
|
let _ = tick(&items, i64::MAX, &settings, &mut state);
|
|
let _ = catch_up(&items, i64::MIN, &settings, &mut state);
|
|
let _ = inbox(&items, i64::MAX, &settings, &state);
|
|
snooze(&mut state, "k", i64::MAX, u32::MAX);
|
|
}
|