Files
Marcos Paulo 15d7f5e873 feat: editor blocks and lint, vault knowledge, calendar plugin, macOS menu
- 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>
2026-10-18 12:36:00 -03:00

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);
}