use super::*;
use chrono::TimeZone;
fn day(s: &str) -> NaiveDate {
NaiveDate::parse_from_str(s, "%Y-%m-%d").unwrap()
}
fn clock(now: &str, today: &str) -> Clock {
let now = DateTime::parse_from_rfc3339(now).unwrap().with_timezone(&Utc);
Clock::new(now, Some(day(today)))
}
fn due(d: &str) -> Deadline {
Deadline { due: d.into(), ..Default::default() }
}
fn item_of(key: &str, d: &Deadline, c: &Clock) -> Option<Item> {
let tags: Vec<String> = vec![];
item(&Task { key, title: "t", status: "open", assignee: "", tags: &tags, deadline: d }, c)
}
fn tagged(key: &str, d: &Deadline, tags: &[&str], c: &Clock) -> Item {
let tags: Vec<String> = tags.iter().map(|t| t.to_string()).collect();
item(&Task { key, title: "t", status: "open", assignee: "", tags: &tags, deadline: d }, c).unwrap()
}
#[test]
fn dates_and_instants_parse_and_a_zoneless_time_does_not() {
assert_eq!(parse_when("2026-03-14"), Some(When::Day(day("2026-03-14"))));
assert!(matches!(parse_when("2026-03-14T17:00:00-07:00"), Some(When::At(_))));
assert!(matches!(parse_when("2026-03-14T17:00-07:00"), Some(When::At(_))));
assert!(matches!(parse_when("2026-03-14T17:00:00Z"), Some(When::At(_))));
for bad in ["2026-03-14T17:00", "14/03/2026", "2026-02-30", "soon", ""] {
assert_eq!(parse_when(bad), None, "{bad}");
}
}
#[test]
fn overdue_within_window_and_outside_window() {
let c = clock("2026-03-10T12:00:00Z", "2026-03-10");
let late = item_of("task-late", &due("2026-03-07"), &c).unwrap();
assert!(late.overdue);
assert_eq!(late.days_left, -3);
assert!(late.surfaced());
let today = item_of("task-today", &due("2026-03-10"), &c).unwrap();
assert!(!today.overdue, "due today is not late yet");
assert_eq!(today.days_left, 0);
let near = item_of("task-near", &due("2026-03-24"), &c).unwrap();
assert_eq!(near.days_left, 14);
assert!(near.surfaced(), "the last day of the default 14-day window is inside it");
let far = item_of("task-far", &due("2026-03-25"), &c).unwrap();
assert!(!far.surfaced(), "15 days out is outside the default window");
}
#[test]
fn the_window_is_the_tasks_own_or_the_default_for_its_kind() {
let c = clock("2026-03-10T12:00:00Z", "2026-03-10");
let in_25 = "2026-04-04";
assert!(!item_of("task-soft", &due(in_25), &c).unwrap().surfaced());
let hard = Deadline { hard: true, ..due(in_25) };
assert!(item_of("task-hard", &hard, &c).unwrap().surfaced(), "hard deadlines default to 30 days");
let short = Deadline { remind_days: Some(3), ..due("2026-03-14") };
assert!(!item_of("task-short", &short, &c).unwrap().surfaced());
let same_day = Deadline { remind_days: Some(0), ..due("2026-03-10") };
assert!(item_of("task-day", &same_day, &c).unwrap().surfaced(), "0 means on the day");
}
#[test]
fn expected_stands_in_until_the_real_date_is_known() {
let c = clock("2026-03-10T12:00:00Z", "2026-03-10");
let waiting = Deadline {
waits_on: "the vendor's quote arrives".into(),
expected: "2026-03-12".into(),
..Default::default()
};
let i = item_of("task-quote", &waiting, &c).unwrap();
assert!(i.provisional);
assert_eq!(i.due, "2026-03-12");
assert_eq!(i.waits_on, "the vendor's quote arrives");
assert!(i.surfaced());
let known = Deadline { due: "2026-03-20".into(), ..waiting };
let i = item_of("task-quote", &known, &c).unwrap();
assert!(!i.provisional, "a real due date wins over the provisional one");
assert_eq!(i.due, "2026-03-20");
assert_eq!(i.waits_on, "", "the event is history once the real date is known");
assert!(item_of("task-none", &Deadline::default(), &c).is_none());
}
#[test]
fn a_bare_date_is_judged_by_the_callers_calendar() {
let c = clock("2026-03-15T02:00:00Z", "2026-03-14");
let i = item_of("task-cert", &due("2026-03-14"), &c).unwrap();
assert!(!i.overdue);
assert_eq!(i.days_left, 0);
let utc = clock("2026-03-15T02:00:00Z", "2026-03-15");
assert!(item_of("task-cert", &due("2026-03-14"), &utc).unwrap().overdue);
}
#[test]
fn an_instant_is_late_once_it_has_passed_in_any_zone() {
let deadline = due("2026-03-14T17:00:00-07:00"); let before = clock("2026-03-14T23:30:00Z", "2026-03-14");
let i = item_of("task-cutoff", &deadline, &before).unwrap();
assert!(!i.overdue);
assert_eq!(i.days_left, 0);
let after = clock("2026-03-15T00:30:00Z", "2026-03-14");
let i = item_of("task-cutoff", &deadline, &after).unwrap();
assert!(i.overdue, "the instant passed, whatever the caller's date says");
let ahead = clock("2026-03-14T23:30:00Z", "2026-03-15");
let i = item_of("task-cutoff", &deadline, &ahead).unwrap();
assert!(i.overdue);
assert_eq!(i.days_left, -1);
}
#[test]
fn a_date_time_follows_the_callers_today_like_a_bare_date() {
let timed = due("2026-11-10T08:30:00-08:00");
let bare = due("2026-11-10");
let on = |today: &str| clock("2026-10-27T04:00:00Z", today);
for (today, days, late) in [("2026-11-09", 1, false), ("2026-11-10", 0, false), ("2026-11-11", -1, true), ("2026-11-15", -5, true)] {
let t = item_of("task-timed", &timed, &on(today)).unwrap();
let b = item_of("task-bare", &bare, &on(today)).unwrap();
assert_eq!((t.days_left, t.overdue), (days, late), "date-time on {today}");
assert_eq!(t.days_left, b.days_left, "the two kinds agree on {today}");
assert_eq!(t.bucket(), if late { "overdue" } else { "this_week" }, "{today}");
}
}
#[test]
fn a_today_sent_for_another_time_is_answered_by_the_calendar_alone() {
let past = due("2026-03-10T08:30:00-08:00");
let now = "2026-10-27T04:00:00Z";
let before = item_of("task-past", &past, &clock(now, "2026-01-01")).unwrap();
assert_eq!((before.days_left, before.overdue), (68, false));
let on = item_of("task-past", &past, &clock(now, "2026-03-10")).unwrap();
assert_eq!((on.days_left, on.overdue), (0, false));
let after = item_of("task-past", &past, &clock(now, "2026-03-11")).unwrap();
assert_eq!((after.days_left, after.overdue), (-1, true));
let tokyo = due("2026-03-15T01:00:00+09:00");
let la_evening = item_of("task-tokyo", &tokyo, &clock("2026-03-15T01:00:00Z", "2026-03-14")).unwrap();
assert!(la_evening.overdue && la_evening.days_left == 0, "{la_evening:?}");
}
#[test]
fn a_date_time_across_the_daylight_saving_change_keeps_its_own_day() {
let c = clock("2026-10-27T04:00:00Z", "2026-11-02");
for written in ["2026-11-01T01:30:00-07:00", "2026-11-01T01:30:00-08:00"] {
let i = item_of("task-dst", &due(written), &c).unwrap();
assert_eq!((i.days_left, i.overdue), (-1, true), "{written}");
}
let before = clock("2026-10-27T04:00:00Z", "2026-10-31");
assert_eq!(item_of("task-dst", &due("2026-11-01T01:30:00-08:00"), &before).unwrap().days_left, 1);
let spring = clock("2026-03-01T00:00:00Z", "2026-03-09");
assert_eq!(item_of("task-dst", &due("2026-03-08T03:30:00-07:00"), &spring).unwrap().days_left, -1);
}
#[test]
fn a_passed_instant_in_a_zone_ahead_is_never_counted_as_days_to_go() {
let deadline = due("2026-03-15T01:00:00+09:00");
let c = clock("2026-03-14T18:00:00Z", "2026-03-14");
let i = item_of("task-tokyo", &deadline, &c).unwrap();
assert!(i.overdue);
assert_eq!(i.days_left, 0, "late, so never +1");
let mut items = vec![item_of("task-a-today", &due("2026-03-14"), &c).unwrap(), i];
sort(&mut items);
assert_eq!(items[0].key, "task-tokyo");
}
#[test]
fn without_a_callers_date_the_server_uses_its_own() {
let now = Utc.with_ymd_and_hms(2026, 3, 15, 2, 0, 0).unwrap();
let c = Clock::new(now, None);
assert_eq!(c.today, now.with_timezone(&chrono::Local).date_naive());
}
#[test]
fn the_block_is_capped_ordered_and_absent_when_there_is_nothing() {
let c = clock("2026-03-10T12:00:00Z", "2026-03-10");
assert!(block(vec![], &c, &[]).is_none());
let far = item_of("task-far", &due("2027-01-01"), &c).unwrap();
assert!(block(vec![far.clone()], &c, &[]).is_none(), "outside every window: no block at all");
let mut items = vec![far];
for (i, d) in ["2026-03-12", "2026-03-11", "2026-03-09", "2026-03-15", "2026-03-20", "2026-03-13"]
.iter()
.enumerate()
{
items.push(item_of(&format!("task-{i}"), &due(d), &c).unwrap());
}
let hard = Deadline { hard: true, ..due("2026-03-22") };
items.push(item_of("task-hard", &hard, &c).unwrap());
let b = block(items, &c, &[]).unwrap();
assert_eq!(b["today"], "2026-03-10");
assert_eq!(b["count"], 7);
assert_eq!(b["overdue"], 1);
assert_eq!(b["more"], 2);
let keys: Vec<&str> = b["items"].as_array().unwrap().iter().map(|i| i["key"].as_str().unwrap()).collect();
assert_eq!(keys, ["task-2", "task-hard", "task-1", "task-0", "task-5"], "late first, then hard, then by date");
}
#[test]
fn a_late_task_is_never_pushed_out_of_the_block_by_distant_hard_ones() {
let c = clock("2026-10-26T12:00:00Z", "2026-10-26");
let mut items: Vec<Item> = (0..6)
.map(|i| {
let hard = Deadline { hard: true, ..due(&format!("2026-11-{:02}", 10 + i)) };
item_of(&format!("task-hard-{i}"), &hard, &c).unwrap()
})
.collect();
items.push(item_of("task-rotate-keys", &due("2026-10-20"), &c).unwrap());
let hard_late = Deadline { hard: true, ..due("2026-10-25") };
items.push(item_of("task-renew-cert", &hard_late, &c).unwrap());
let b = block(items, &c, &[]).unwrap();
let keys: Vec<&str> = b["items"].as_array().unwrap().iter().map(|i| i["key"].as_str().unwrap()).collect();
assert_eq!(&keys[..2], ["task-renew-cert", "task-rotate-keys"], "late first, hard before soft: {keys:?}");
assert_eq!(keys[2], "task-hard-0", "then what is coming, nearest first");
assert_eq!(b["more"], 3);
}
#[test]
fn a_scoped_question_shows_its_own_area_first() {
let c = clock("2026-03-10T12:00:00Z", "2026-03-10");
let items = vec![
tagged("task-billing-late", &due("2026-03-08"), &["billing"], &c),
tagged("task-billing", &due("2026-03-11"), &["billing"], &c),
tagged("task-cert", &due("2026-03-12"), &["infra", "tls"], &c),
];
let order = |scope: &[String]| -> Vec<String> {
let b = block(items.clone(), &c, scope).unwrap();
b["items"].as_array().unwrap().iter().map(|i| i["key"].as_str().unwrap().to_string()).collect()
};
assert_eq!(order(&["TLS".into()]), ["task-billing-late", "task-cert", "task-billing"]);
assert_eq!(order(&[]), ["task-billing-late", "task-billing", "task-cert"]);
}
#[test]
fn buckets_for_the_listing() {
let c = clock("2026-03-10T12:00:00Z", "2026-03-10");
assert_eq!(item_of("a", &due("2026-03-09"), &c).unwrap().bucket(), "overdue");
assert_eq!(item_of("b", &due("2026-03-17"), &c).unwrap().bucket(), "this_week");
assert_eq!(item_of("c", &due("2026-03-18"), &c).unwrap().bucket(), "later");
}
#[test]
fn validation() {
let task = |d: Deadline| d.validate("task", true);
assert!(task(Deadline::default()).is_ok());
assert!(task(due("2026-03-14")).is_ok());
assert!(task(Deadline { hard: true, remind_days: Some(60), ..due("2026-03-14T17:00:00Z") }).is_ok());
assert!(task(Deadline { waits_on: "quote".into(), expected: "2026-03-14".into(), ..Default::default() }).is_ok());
let err = |d: Deadline| task(d).unwrap_err().to_string();
assert!(err(due("next friday")).contains("due must be"));
assert!(err(Deadline { expected: "2026-13-01".into(), ..Default::default() }).contains("expected must be"));
assert!(err(Deadline { hard: true, ..Default::default() }).contains("set due, or expected"));
assert!(err(Deadline { waits_on: "quote".into(), ..Default::default() }).contains("set due, or expected"));
assert!(err(Deadline { remind_days: Some(400), ..due("2026-03-14") }).contains("at most"));
assert!(err(Deadline { waits_on: " ".into(), ..due("2026-03-14") }).contains("blank"));
let token = format!("token ghp_{}", "a1".repeat(18));
assert!(err(Deadline { waits_on: token, ..due("2026-03-14") }).contains("secret"));
let knowledge = due("2026-03-14").validate("knowledge", false).unwrap_err().to_string();
assert!(knowledge.contains("task-only"), "{knowledge}");
}
#[test]
fn a_patch_sets_what_it_names_and_keeps_the_rest() {
let stored = Deadline { hard: true, remind_days: Some(20), ..due("2026-03-14") };
let patch = |j: &str| serde_json::from_str::<DeadlinePatch>(j).unwrap().apply(stored.clone());
assert_eq!(patch("{}"), stored, "nothing named, nothing changes");
assert_eq!(patch(r#"{"due":"2026-03-21"}"#), Deadline { due: "2026-03-21".into(), ..stored.clone() });
assert_eq!(patch(r#"{"remind_days":null}"#).remind_days, None, "null clears to the default");
assert_eq!(patch(r#"{"remind_days":5}"#).remind_days, Some(5));
assert!(!patch(r#"{"hard":false}"#).hard);
assert_eq!(patch(r#"{"due":""}"#).due, "", "an empty string clears");
}
#[test]
fn clearing_the_date_takes_what_described_it_along() {
let stored = Deadline {
hard: true,
remind_days: Some(20),
waits_on: "the CA's approval".into(),
..due("2026-03-14")
};
let patch = |j: &str| serde_json::from_str::<DeadlinePatch>(j).unwrap().apply(stored.clone());
for clear in [r#"{"due":""}"#, r#"{"due":null}"#] {
let d = patch(clear);
assert_eq!(d, Deadline::default(), "{clear}");
assert!(d.validate("task", true).is_ok(), "{clear}: clearing is a valid write");
}
let d = patch(r#"{"due":"","hard":true}"#);
assert!(d.hard);
assert!(d.validate("task", true).is_err());
assert!(!patch(r#"{"hard":null}"#).hard);
assert_eq!(patch(r#"{"waits_on":null}"#).waits_on, "");
let provisional = Deadline { waits_on: "quote".into(), expected: "2026-03-20".into(), ..Default::default() };
let d = serde_json::from_str::<DeadlinePatch>(r#"{"expected":null}"#).unwrap().apply(provisional);
assert_eq!(d, Deadline::default());
}
#[test]
fn diff_fields_read_like_the_other_fields() {
let d = Deadline { hard: true, remind_days: Some(7), ..due("2026-03-14") };
let fields = d.diff_fields();
assert_eq!(fields[0], ("due", "2026-03-14".to_string()));
assert_eq!(fields[1], ("hard", "true".to_string()));
assert_eq!(fields[2], ("remind_days", "7".to_string()));
assert_eq!(Deadline::default().diff_fields()[1], ("hard", String::new()));
}
#[test]
fn the_frontmatter_carries_only_the_fields_that_are_set_and_reads_them_back() {
use crate::model::Entry;
let mut e = Entry {
key: "task-renew-cert".into(),
title: "Renew the certificate".into(),
kind: "task".into(),
status: "open".into(),
body: "before it expires".into(),
..Default::default()
};
let plain = e.to_markdown();
for field in ["due:", "hard:", "remind_days:", "waits_on:", "expected:"] {
assert!(!plain.contains(field), "a task without a deadline is stored as before: {plain}");
}
e.deadline = Deadline { hard: true, remind_days: Some(21), ..due("2026-03-14T17:00:00-07:00") };
let md = e.to_markdown();
assert!(md.contains("hard: true") && md.contains("remind_days: 21"), "{md}");
assert!(!md.contains("waits_on:"), "{md}");
let back = Entry::from_markdown(&md).unwrap();
assert_eq!(back.deadline, e.deadline);
assert!(back.same_content(&e));
let moved = Entry { deadline: due("2026-03-21"), ..e.clone() };
assert!(!moved.same_content(&e), "moving the date is a change, so it is a version");
let (fields, _) = crate::model::diff_entries(&e, &moved);
let names: Vec<&str> = fields.iter().map(|f| f.field).collect();
assert_eq!(names, ["due", "hard", "remind_days"], "{fields:?}");
}