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>
451 lines
19 KiB
Rust
451 lines
19 KiB
Rust
#![allow(clippy::assert_is_empty)]
|
||
//! Public-surface tests of the calendar view: every mode draws, long titles are cut with an
|
||
//! ellipsis, clicks report what to open, and the view asks for the data it lacks.
|
||
|
||
use std::time::Instant;
|
||
|
||
use egui::{Event, PointerButton, Pos2, Rect, Vec2};
|
||
use notescraft_calendar::{Item, Kind};
|
||
use notescraft_templates::{Date, Weekday};
|
||
use notescraft_themes::builtin;
|
||
use notescraft_ui_egui::calendar_view::{CalendarData, CalendarResponse, CalendarView, Mode, show_calendar};
|
||
use notescraft_ui_egui::theme::Tokens;
|
||
|
||
fn tokens() -> Tokens {
|
||
Tokens::new(builtin("catppuccin-mocha").expect("theme"))
|
||
}
|
||
|
||
fn date(text: &str) -> Date {
|
||
text.parse::<notescraft_calendar::EventTime>().expect("date").date()
|
||
}
|
||
|
||
fn item(id: &str, title: &str, start: &str, end: Option<&str>) -> Item {
|
||
Item {
|
||
id: id.to_owned(),
|
||
kind: Kind::Event,
|
||
title: title.to_owned(),
|
||
start: start.parse().expect("start"),
|
||
end: end.map(|e| e.parse().expect("end")),
|
||
calendar: Some("Work".to_owned()),
|
||
tags: vec![],
|
||
priority: None,
|
||
status: None,
|
||
has_reminder: false,
|
||
reminders: vec![],
|
||
note: None,
|
||
created: None,
|
||
done: false,
|
||
repeats: false,
|
||
source: None,
|
||
tz: None,
|
||
}
|
||
}
|
||
|
||
fn sample() -> Vec<Item> {
|
||
vec![
|
||
item("Calendar/standup.md", "Standup", "2026-10-19T09:30", Some("2026-10-19T09:45")),
|
||
item("Calendar/lunch.md", "Lunch", "2026-10-20T12:00", Some("2026-10-20T13:00")),
|
||
item("Calendar/clash.md", "Dentist", "2026-10-20T12:30", Some("2026-10-20T13:30")),
|
||
item("Calendar/trip.md", "Trip to the mountains with the whole family and friends", "2026-10-21", Some("2026-10-23")),
|
||
]
|
||
}
|
||
|
||
fn view(mode: Mode) -> CalendarView {
|
||
let mut view = CalendarView::new(date("2026-10-20"), Weekday::Monday);
|
||
view.mode = mode;
|
||
view
|
||
}
|
||
|
||
fn data_for(view: &CalendarView, items: Vec<Item>) -> CalendarData {
|
||
CalendarData {
|
||
items,
|
||
window: view.window(),
|
||
saved: vec![],
|
||
feed_errors: vec![],
|
||
inbox: notescraft_calendar::Inbox::default(),
|
||
snooze_minutes: vec![5, 15],
|
||
review: None,
|
||
}
|
||
}
|
||
|
||
struct Frame {
|
||
response: CalendarResponse,
|
||
texts: Vec<(Pos2, String)>,
|
||
shapes: usize,
|
||
}
|
||
|
||
fn collect(shape: &egui::Shape, out: &mut Vec<(Pos2, String)>) {
|
||
match shape {
|
||
egui::Shape::Text(text) => out.push((text.pos, text.galley.rows.iter().map(|row| row.text()).collect::<String>())),
|
||
egui::Shape::Vec(shapes) => shapes.iter().for_each(|inner| collect(inner, out)),
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
fn run(ctx: &egui::Context, view: &mut CalendarView, data: &CalendarData, events: Vec<Event>) -> Frame {
|
||
run_with(ctx, view, data, events, egui::Modifiers::NONE)
|
||
}
|
||
|
||
fn run_with(ctx: &egui::Context, view: &mut CalendarView, data: &CalendarData, mut events: Vec<Event>, modifiers: egui::Modifiers) -> Frame {
|
||
events.insert(0, Event::ModifiersChanged(modifiers));
|
||
let tokens = tokens();
|
||
let input = egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(1200.0, 800.0))), events, ..Default::default() };
|
||
let mut response = CalendarResponse::default();
|
||
let mut out = ctx.run_ui(input, |ui| {
|
||
response = show_calendar(ui, &tokens, view, data);
|
||
});
|
||
out.textures_delta.clear();
|
||
let mut texts = Vec::new();
|
||
out.shapes.iter().for_each(|clipped| collect(&clipped.shape, &mut texts));
|
||
Frame { response, shapes: out.shapes.len(), texts }
|
||
}
|
||
|
||
/// A fresh context warmed up with one frame, which only installs the fonts.
|
||
fn warm(view: &mut CalendarView, data: &CalendarData) -> egui::Context {
|
||
let ctx = egui::Context::default();
|
||
notescraft_ui_egui::fonts::install(&ctx);
|
||
run(&ctx, view, data, vec![]);
|
||
ctx
|
||
}
|
||
|
||
fn has(frame: &Frame, needle: &str) -> bool {
|
||
frame.texts.iter().any(|(_, text)| text.contains(needle))
|
||
}
|
||
|
||
#[test]
|
||
fn every_mode_draws_what_it_promises() {
|
||
for (mode, expected) in [
|
||
(Mode::Month, vec!["October 2026", "Mon", "09:30 Standup", "12:00 Lunch"]),
|
||
(Mode::Week, vec!["19 Oct – 25 Oct 2026", "Mon", "09:30 Standup", "12:30 Den", "All day"]),
|
||
(Mode::Day, vec!["Tuesday 20 October 2026", "12:00 Lunch", "12:30 Dentist"]),
|
||
(Mode::Agenda, vec!["Tuesday 20 October", "12:00", "Lunch", "Today"]),
|
||
(Mode::Year, vec!["2026", "January", "December"]),
|
||
] {
|
||
let mut view = view(mode);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
let frame = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(frame.shapes > 0, "{mode:?} paints");
|
||
for needle in expected {
|
||
assert!(has(&frame, needle), "{mode:?} should show `{needle}`; shown: {:?}", frame.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
|
||
}
|
||
assert!(frame.response.reload.is_none(), "{mode:?} has the data it needs");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn long_titles_end_in_an_ellipsis() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
let frame = run(&ctx, &mut view, &data, vec![]);
|
||
let cut: Vec<&str> = frame.texts.iter().map(|(_, t)| t.as_str()).filter(|t| t.contains("Trip")).collect();
|
||
assert!(!cut.is_empty(), "the trip is drawn on its days");
|
||
assert!(cut.iter().all(|t| t.ends_with('…') && t.len() < "Trip to the mountains with the whole family and friends".len()), "{cut:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn an_empty_agenda_says_so() {
|
||
let mut view = view(Mode::Agenda);
|
||
let data = data_for(&view, vec![]);
|
||
let ctx = warm(&mut view, &data);
|
||
assert!(has(&run(&ctx, &mut view, &data, vec![]), "Nothing scheduled"));
|
||
}
|
||
|
||
#[test]
|
||
fn clicking_a_chip_opens_its_file() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
let frame = run(&ctx, &mut view, &data, vec![]);
|
||
let (at, _) = frame.texts.iter().find(|(_, t)| t.contains("Lunch")).expect("lunch chip").clone();
|
||
let target = at + Vec2::new(6.0, 4.0);
|
||
run(&ctx, &mut view, &data, vec![Event::PointerMoved(target)]);
|
||
run(&ctx, &mut view, &data, vec![Event::PointerButton { pos: target, button: PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }]);
|
||
let released = run(
|
||
&ctx,
|
||
&mut view,
|
||
&data,
|
||
vec![Event::PointerButton { pos: target, button: PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }],
|
||
);
|
||
assert_eq!(released.response.open.as_deref(), Some("Calendar/lunch.md"));
|
||
}
|
||
|
||
#[test]
|
||
fn the_view_asks_for_the_data_it_lacks() {
|
||
let mut view = view(Mode::Month);
|
||
let stale = CalendarData::empty((date("2026-01-01"), date("2026-01-31")));
|
||
let ctx = warm(&mut view, &stale);
|
||
assert_eq!(run(&ctx, &mut view, &stale, vec![]).response.reload, Some(view.window()));
|
||
view.mode = Mode::Week;
|
||
let loaded = data_for(&view, vec![]);
|
||
assert!(run(&ctx, &mut view, &loaded, vec![]).response.reload.is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn stepping_moves_the_window() {
|
||
let mut view = view(Mode::Month);
|
||
let before = view.window();
|
||
view.step(1);
|
||
assert_ne!(view.window(), before);
|
||
assert_eq!(view.cursor, date("2026-11-20"));
|
||
view.go_today();
|
||
assert_eq!(view.cursor, date("2026-10-20"));
|
||
}
|
||
|
||
#[test]
|
||
#[ignore = "benchmark: run with --release --ignored"]
|
||
fn a_month_of_ten_thousand_events_draws_fast() {
|
||
let mut view = view(Mode::Month);
|
||
let items: Vec<Item> =
|
||
(0..10_000_u32).map(|n| item(&format!("e{n}.md"), &format!("Event {n}"), &format!("2026-10-{:02}T{:02}:00", 1 + n % 28, n % 24), None)).collect();
|
||
let data = data_for(&view, items);
|
||
let ctx = warm(&mut view, &data);
|
||
let started = Instant::now();
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let took = started.elapsed();
|
||
assert!(took.as_millis() < 16, "took {took:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn typed_keys_move_the_cursor_unless_a_prompt_owns_the_keyboard() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
run(&ctx, &mut view, &data, vec![Event::Text("l".to_owned())]);
|
||
assert_eq!(view.cursor, date("2026-10-21"), "l moves one day");
|
||
run(&ctx, &mut view, &data, vec![Event::Text("gw".to_owned())]);
|
||
assert_eq!(view.mode, Mode::Week, "g then w switches to the week view");
|
||
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::GoTo);
|
||
let before = view.cursor;
|
||
run(&ctx, &mut view, &data, vec![Event::Text("l".to_owned())]);
|
||
assert_eq!(view.cursor, before, "an open prompt keeps the keys to itself");
|
||
}
|
||
|
||
fn key(key: egui::Key) -> Event {
|
||
Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }
|
||
}
|
||
|
||
/// Moves, presses and releases the pointer at `at`; returns the frame of the release.
|
||
fn click(ctx: &egui::Context, view: &mut CalendarView, data: &CalendarData, at: Pos2) -> Frame {
|
||
run(ctx, view, data, vec![Event::PointerMoved(at)]);
|
||
run(ctx, view, data, vec![Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }]);
|
||
run(ctx, view, data, vec![Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }])
|
||
}
|
||
|
||
fn centre_of(frame: &Frame, text: &str) -> Pos2 {
|
||
let exact = frame.texts.iter().find(|(_, shown)| shown.as_str() == text);
|
||
let found = exact.or_else(|| frame.texts.iter().find(|(_, shown)| shown.contains(text)));
|
||
let (at, _) = found.unwrap_or_else(|| panic!("no `{text}` in {:?}", frame.texts.iter().map(|(_, shown)| shown.as_str()).collect::<Vec<_>>()));
|
||
*at + Vec2::new(8.0, 6.0)
|
||
}
|
||
|
||
#[test]
|
||
fn quick_add_previews_what_it_understood_and_saves_only_on_enter() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::QuickAdd);
|
||
view.prompt_text = "Lunch tomorrow at 12:30 for 1h".to_owned();
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let shown = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&shown, "Lunch · 2026-10-21 12:30"), "{:?}", shown.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
|
||
assert!(shown.response.commands.is_empty(), "typing saves nothing");
|
||
|
||
let entered = run(&ctx, &mut view, &data, vec![key(egui::Key::Enter)]);
|
||
assert_eq!(entered.response.commands.len(), 1);
|
||
assert_eq!(entered.response.commands[0].0, "calendar.add");
|
||
assert_eq!(entered.response.commands[0].1["text"], "Lunch tomorrow at 12:30 for 1h");
|
||
assert!(view.prompt.is_none(), "the prompt closes after saving");
|
||
assert_eq!(view.cursor, date("2026-10-21"), "the view moves to the new event");
|
||
}
|
||
|
||
#[test]
|
||
fn escape_closes_the_prompt_and_saves_nothing() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::QuickAdd);
|
||
view.prompt_text = "Lunch tomorrow".to_owned();
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let closed = run(&ctx, &mut view, &data, vec![key(egui::Key::Escape)]);
|
||
assert!(view.prompt.is_none() && view.prompt_text.is_empty());
|
||
assert!(closed.response.commands.is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn a_phrase_that_cannot_be_read_names_the_bad_part_and_stays_open() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::QuickAdd);
|
||
view.prompt_text = "Lunch at 25:00".to_owned();
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let shown = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&shown, "Cannot read `25:00`"), "{:?}", shown.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
|
||
let entered = run(&ctx, &mut view, &data, vec![key(egui::Key::Enter)]);
|
||
assert!(entered.response.commands.is_empty());
|
||
assert!(view.prompt.is_some(), "the prompt stays open so the phrase can be fixed");
|
||
}
|
||
|
||
#[test]
|
||
fn go_to_a_date_moves_the_cursor() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::GoTo);
|
||
view.prompt_text = "2026-12-25".to_owned();
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
run(&ctx, &mut view, &data, vec![key(egui::Key::Enter)]);
|
||
assert_eq!(view.cursor, date("2026-12-25"));
|
||
assert!(view.prompt.is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn the_bulk_bar_counts_before_it_applies() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
view.bulk = Some(vec!["Calendar/lunch.md".to_owned(), "Calendar/clash.md".to_owned()]);
|
||
view.bulk_text = "2".to_owned();
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let shown = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&shown, "2 events selected"), "the count shows before anything is applied");
|
||
assert!(shown.response.commands.is_empty());
|
||
let applied = click(&ctx, &mut view, &data, centre_of(&shown, "Apply to 2"));
|
||
assert_eq!(applied.response.commands.len(), 1);
|
||
let (id, params) = &applied.response.commands[0];
|
||
assert_eq!(id, "calendar.bulk");
|
||
assert_eq!((params["action"].as_str(), params["days"].as_i64(), params["confirm"].as_bool()), (Some("move"), Some(2), Some(true)));
|
||
assert!(view.bulk.is_none(), "the bar closes after applying");
|
||
}
|
||
|
||
#[test]
|
||
fn the_filter_popover_filters_and_saves() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
view.filter_open = true;
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let shown = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&shown, "Calendars") && has(&shown, "Saved filters"));
|
||
click(&ctx, &mut view, &data, centre_of(&shown, "Work"));
|
||
assert_eq!(view.query.filter.calendars, ["Work"]);
|
||
view.save_name = "Mine".to_owned();
|
||
let after = run(&ctx, &mut view, &data, vec![]);
|
||
let saved = click(&ctx, &mut view, &data, centre_of(&after, "Save"));
|
||
let (id, params) = saved.response.commands.first().expect("a save command");
|
||
assert_eq!(id, "calendar.filter_save");
|
||
assert_eq!(params["name"], "Mine");
|
||
assert_eq!(params["query"]["filter"]["calendars"][0], "Work");
|
||
}
|
||
|
||
#[test]
|
||
fn the_review_panel_lists_the_week() {
|
||
let mut view = view(Mode::Month);
|
||
let items = sample();
|
||
let mut data = data_for(&view, items.clone());
|
||
data.review = Some(notescraft_calendar::week_review(&items, date("2026-10-19")));
|
||
let ctx = warm(&mut view, &data);
|
||
view.review = Some(date("2026-10-20"));
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let shown = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&shown, "Week of 2026-10-19") && has(&shown, "Standup"), "{:?}", shown.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
|
||
run(&ctx, &mut view, &data, vec![key(egui::Key::Escape)]);
|
||
assert!(view.review.is_none(), "Esc closes the panel");
|
||
}
|
||
|
||
#[test]
|
||
fn the_inbox_lists_due_missed_and_snoozed_alerts_with_actions() {
|
||
use notescraft_calendar::{Alert, Inbox};
|
||
let alert = |title: &str, key: &str| Alert {
|
||
key: key.to_owned(),
|
||
item_id: format!("Calendar/{title}.md"),
|
||
title: title.to_owned(),
|
||
start: "2026-10-20T09:30".parse().unwrap(),
|
||
minutes_before: 10,
|
||
fire_at: 0,
|
||
};
|
||
let mut view = view(Mode::Month);
|
||
let mut data = data_for(&view, sample());
|
||
data.inbox = Inbox {
|
||
due: vec![alert("Standup", "a|1|10")],
|
||
upcoming: vec![alert("Lunch", "b|2|10")],
|
||
snoozed: vec![(alert("Dentist", "c|3|10"), 600)],
|
||
missed: vec![alert("Review", "d|4|10")],
|
||
};
|
||
let ctx = warm(&mut view, &data);
|
||
let closed = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&closed, "Reminders (2)"), "the button counts what needs attention: {:?}", closed.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
|
||
view.inbox_open = true;
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let shown = run(&ctx, &mut view, &data, vec![]);
|
||
for needle in ["Due now", "Missed", "Snoozed", "Upcoming", "back at 10:00", "Snooze 5 min", "Dismiss"] {
|
||
assert!(has(&shown, needle), "{needle}");
|
||
}
|
||
let snoozed = click(&ctx, &mut view, &data, centre_of(&shown, "Snooze 5 min"));
|
||
let (id, params) = snoozed.response.commands.first().expect("a snooze command");
|
||
assert_eq!((id.as_str(), params["minutes"].as_i64()), ("calendar.reminder_snooze", Some(5)));
|
||
assert!(params["key"].as_str().is_some_and(|key| key.ends_with("|10")));
|
||
run(&ctx, &mut view, &data, vec![key(egui::Key::Escape)]);
|
||
assert!(!view.inbox_open, "Esc closes the inbox");
|
||
}
|
||
|
||
#[test]
|
||
fn offline_feeds_are_flagged_and_imported_events_are_read_only() {
|
||
let mut view = view(Mode::Month);
|
||
let mut imported = item("feed:team:a@x", "Board meeting", "2026-10-20T09:30", None);
|
||
imported.source = Some("team".to_owned());
|
||
let mut data = data_for(&view, vec![imported]);
|
||
data.feed_errors = vec!["Team".to_owned()];
|
||
let ctx = warm(&mut view, &data);
|
||
let frame = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&frame, "Offline: showing saved events of Team"));
|
||
assert!(has(&frame, "Board meeting"), "cached events still show");
|
||
let clicked = click(&ctx, &mut view, &data, centre_of(&frame, "Board meeting"));
|
||
assert_eq!(clicked.response.open, None, "an imported event has no file to open");
|
||
}
|
||
|
||
#[test]
|
||
fn shift_click_selects_a_range_of_days_for_the_bulk_bar() {
|
||
let mut view = view(Mode::Month);
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
let shown = run(&ctx, &mut view, &data, vec![]);
|
||
let (first, _) = shown.texts.iter().find(|(_, t)| t == "22").expect("the 22nd").clone();
|
||
let target = first + Vec2::new(40.0, 40.0);
|
||
let shift = egui::Modifiers::SHIFT;
|
||
let press = |pressed| Event::PointerButton { pos: target, button: PointerButton::Primary, pressed, modifiers: shift };
|
||
run_with(&ctx, &mut view, &data, vec![Event::PointerMoved(target)], shift);
|
||
run_with(&ctx, &mut view, &data, vec![press(true)], shift);
|
||
run_with(&ctx, &mut view, &data, vec![press(false)], shift);
|
||
assert_eq!(view.cursor, date("2026-10-22"));
|
||
assert_eq!(view.keys.range(view.cursor).map(|(from, to)| (from.day(), to.day())), Some((20, 22)), "the range runs from the day the cursor was on");
|
||
run(&ctx, &mut view, &data, vec![Event::Text("x".to_owned())]);
|
||
assert!(view.bulk.as_ref().is_some_and(|ids| ids.contains(&"Calendar/lunch.md".to_owned())), "x opens the bulk bar on the events in the range");
|
||
}
|
||
|
||
#[test]
|
||
fn twelve_hour_clocks_and_week_numbers_follow_the_settings() {
|
||
let mut view = view(Mode::Month);
|
||
view.time_24h = false;
|
||
view.week_numbers = true;
|
||
let data = data_for(&view, sample());
|
||
let ctx = warm(&mut view, &data);
|
||
let month = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&month, "9:30 AM Standup") && has(&month, "12:00 PM Lunch"), "{:?}", month.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
|
||
assert!(month.texts.iter().any(|(_, text)| text == "43"), "ISO week 43 holds 19 to 25 October");
|
||
view.mode = Mode::Week;
|
||
let data = data_for(&view, sample());
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let week = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&week, "1:00 PM"), "the hour labels follow the clock style");
|
||
view.time_24h = true;
|
||
view.week_numbers = false;
|
||
view.mode = Mode::Month;
|
||
let data = data_for(&view, sample());
|
||
run(&ctx, &mut view, &data, vec![]);
|
||
let plain = run(&ctx, &mut view, &data, vec![]);
|
||
assert!(has(&plain, "09:30 Standup") && !plain.texts.iter().any(|(_, text)| text == "43"));
|
||
}
|