mod chrome; mod stages; mod timeline; mod tree; use std::time::Duration; use jiff::fmt::friendly::{Designator, FractionalUnit, Spacing, SpanPrinter}; use ratatui::{ buffer::Buffer, layout::{Constraint, Layout, Rect}, style::Color, text::Line, widgets::{Block, Borders, Widget}, }; use unicode_truncate::UnicodeTruncateStr; use unicode_width::UnicodeWidthStr; pub use self::chrome::PasswordPrompt; use self::{ chrome::{FOOTER_HEIGHT, Footer, Header, PasswordPopup}, stages::Stages, timeline::{RunningRun, Timeline}, tree::UnitTree, }; use crate::{ colors::Colors, config::Timing, glyphs::Glyphs, model::{BootState, RowStatus, TreeRow, UnitKind, fit_to_height, fold_chains}, origin::BootOrigin, }; const DURATION_WIDTH: u16 = 8; const MIN_BAR_WIDTH: u16 = 12; const MIN_HEIGHT_FOR_TIMELINE: u16 = 12; const MIN_TIMELINE_HEIGHT: u16 = timeline::CHROME_HEIGHT + 4; const HEADER_HEIGHT: u16 = 1; const BRANCH: &str = "├─ "; const LAST_BRANCH: &str = "└─ "; const PASSING_TRUNK: &str = "│ "; const ENDED_TRUNK: &str = " "; const ELAPSED: SpanPrinter = SpanPrinter::new() .designator(Designator::Compact) .spacing(Spacing::None) .fractional(Some(FractionalUnit::Second)) .precision(Some(1)); pub struct BootView<'a> { pub state: &'a BootState, pub colors: &'a Colors, pub timing: &'a Timing, pub glyphs: &'a Glyphs, pub now: Duration, pub origin: &'a BootOrigin, pub frame: u64, pub password_prompt: Option>, } impl BootView<'_> { fn timeline<'a>(&'a self, rows: &'a [TreeRow]) -> Timeline<'a> { let mut running: Vec = rows .iter() .filter(|row| row.kind != UnitKind::Target) .filter_map(|row| match row.status { RowStatus::Running { queued_at, since } => Some(RunningRun { label: &row.label, queued_at, since, }), _ => None, }) .collect(); running.sort_by_key(|run| run.since); Timeline { origin: self.state.origin, now: self.now, root_switches: self .state .finished_stages .iter() .map(|stage| stage.reached_at) .collect(), milestones: self.state.milestones(), finished: self .state .finished_runs .iter() .filter(|run| { run.finished_at.saturating_sub(run.started_at) >= self.timing.hide_runs_shorter_than }) .collect(), running, colors: &self.colors.timeline, glyphs: self.glyphs, } } } impl Widget for BootView<'_> { fn render(self, area: Rect, buf: &mut Buffer) { let all_rows = self .state .tree_rows(self.now.saturating_sub(self.timing.keep_finished_units_for)); let pending_count = all_rows.len(); let header = Header { origin: self.origin, total: (!self.state.finished_stages.is_empty()) .then(|| self.now.saturating_sub(self.state.origin)), colors: &self.colors.header, }; let stages = Stages { state: self.state, now: self.now, colors: &self.colors.stages, glyphs: self.glyphs, }; let timeline = self.timeline(&all_rows); let footer = Footer { tally: self.state.tally(), colors: &self.colors.footer, glyphs: self.glyphs, }; let fits_timeline = area.width >= timeline::LABEL_WIDTH + 1 + MIN_BAR_WIDTH && area.height >= MIN_HEIGHT_FOR_TIMELINE; let free = area .height .saturating_sub(HEADER_HEIGHT + stages.height() + FOOTER_HEIGHT); let heights = Heights::share( free, UnitTree::height_of(pending_count, 0), if fits_timeline { timeline.height() } else { 0 }, ); let budget = usize::from(heights.tree.saturating_sub(1)); let rows = [all_rows.clone(), fold_chains(all_rows.clone())] .into_iter() .find(|rows| rows.len() <= budget) .unwrap_or_else(|| fold_chains(fit_to_height(all_rows.clone(), budget))); let tree = UnitTree { phase: stages.current_phase(), rows: &rows, hidden: pending_count - shown_units(&rows), now: self.now, hide_runs_shorter_than: self.timing.hide_runs_shorter_than, frame: self.frame, colors: &self.colors.tree, glyphs: self.glyphs, }; let tree_height = tree.height().min(heights.tree); let [ header_area, stage_area, tree_area, _, timeline_area, footer_area, ] = Layout::vertical([ Constraint::Length(HEADER_HEIGHT), Constraint::Length(stages.height()), Constraint::Length(tree_height), Constraint::Fill(1), Constraint::Length(heights.timeline), Constraint::Length(FOOTER_HEIGHT), ]) .areas(area); header.render(header_area, buf); stages.render(stage_area, buf); tree.render(tree_area, buf); if heights.timeline > 0 { timeline.render(timeline_area, buf); } footer.render(footer_area, buf); if let Some(asking) = &self.password_prompt { PasswordPopup { asking, colors: &self.colors.password, glyphs: self.glyphs, } .render(area, buf); } } } struct Heights { tree: u16, timeline: u16, } impl Heights { fn share(free: u16, tree_need: u16, timeline_need: u16) -> Self { let leftover = free.saturating_sub(tree_need); let timeline = if leftover >= MIN_TIMELINE_HEIGHT { timeline_need.min(leftover) } else { 0 }; Self { tree: free - timeline, timeline, } } } fn rule(color: Color, left: Line<'static>) -> Block<'static> { Block::new() .borders(Borders::TOP) .border_style(color) .title(left) } fn shown_units(rows: &[TreeRow]) -> usize { rows.iter().map(|row| 1 + row.chain.len()).sum() } fn fit_width(text: &str, room: usize, ellipsis: &str) -> String { if text.width() <= room { return text.to_owned(); } let (kept, _) = text.unicode_truncate(room.saturating_sub(ellipsis.width())); format!("{kept}{ellipsis}") } fn unit_count(count: usize) -> String { match count { 1 => "1 unit".to_owned(), count => format!("{count} units"), } } #[cfg(test)] mod tests { use ratatui::{Terminal, backend::TestBackend}; use super::*; use crate::model::{ActiveState, Activity, JobKind, JobResult, Phase, UnitFacts}; const MS: Duration = Duration::from_millis(1); fn facts(name: &str, after: &[&str]) -> UnitFacts { UnitFacts { name: name.to_owned(), description: String::new(), after: after.iter().map(ToString::to_string).collect(), before: Vec::new(), } } fn render(state: &BootState, now: Duration, width: u16, height: u16) -> Vec { screen_lines(&render_prompted(state, now, width, height, None)) } fn render_prompted( state: &BootState, now: Duration, width: u16, height: u16, password_prompt: Option, ) -> Buffer { let mut terminal = Terminal::new(TestBackend::new(width, height)).expect("test backend"); terminal .draw(|frame| { frame.render_widget( BootView { state, colors: &Colors::default(), timing: &Timing::default(), glyphs: &Glyphs::default(), now, origin: &BootOrigin { host: "ryzen".to_owned(), system: "NixOS 26.11".to_owned(), generation: "2771".to_owned(), kernel: "Linux 7.2.9".to_owned(), }, frame: 1, password_prompt, }, frame.area(), ); }) .expect("draw"); terminal.backend().buffer().clone() } fn screen_lines(buffer: &Buffer) -> Vec { let area = buffer.area; (0..area.height) .map(|y| { let line: String = (0..area.width) .map(|x| buffer[(x, y)].symbol().to_owned()) .collect(); line.trim_end().to_owned() }) .collect() } fn running_since(since: Duration) -> Activity { Activity { state: Some(ActiveState::Activating), inactive_exit: Some(since), active_enter: None, active_exit: None, } } fn boot_in_progress() -> BootState { let mut state = BootState::new(Phase::Host); state.set_root("graphical.target".to_owned()); [ ( facts("graphical.target", &["multi-user.target"]), Activity::default(), ), ( facts( "multi-user.target", &["docker.service", "systemd-rfkill.service", "web.service"], ), Activity::default(), ), (facts("docker.service", &[]), running_since(9000 * MS)), ( facts("systemd-rfkill.service", &[]), running_since(6000 * MS), ), (facts("web.service", &[]), Activity::default()), (facts("sysinit.target", &[]), Activity::default()), (facts("nvidia-powerd.service", &[]), Activity::default()), (facts("udev-settle.service", &[]), running_since(2000 * MS)), ] .into_iter() .zip(1..) .for_each(|((unit, activity), id)| { let name = unit.name.clone(); state.track_unit(unit, activity); state.queue_job(id, &name, JobKind::BringsUp, 1000 * MS); }); state.finish_job(6, JobResult::Done, 4000 * MS); state.finish_job(7, JobResult::Failed, 5000 * MS); state.finish_job(8, JobResult::Done, 3500 * MS); state } #[test] fn tree_on_top_timeline_below() { let lines = render(&boot_in_progress(), 12_400 * MS, 110, 24); let screen = lines.join("\n"); assert_eq!( lines[0], "ryzen · NixOS 26.11 · generation 2771 · Linux 7.2.9", "{screen}" ); assert!(lines[1].starts_with("└─ Stage 2 12.4s"), "{screen}"); assert!(lines[1].ends_with("Running"), "{screen}"); assert!( lines[2].starts_with(" ├─ ◆ multi-user.target"), "{screen}" ); assert!( lines[3].starts_with(" │ ├─ [/] systemd-rfkill"), "{screen}" ); assert!(lines[4].starts_with(" │ ├─ [/] docker"), "{screen}"); assert!(lines[5].starts_with(" │ └─ [ ] web"), "{screen}"); assert!(lines[6].starts_with(" ├─ ◇ graphical.target"), "{screen}"); assert!(lines[7].starts_with(" └─ [×] nvidia-powerd"), "{screen}"); let timeline = lines .iter() .position(|line| line.contains(" Timeline ")) .expect("timeline panel"); assert!( lines[timeline + 1].starts_with(&format!("{:29}Kernel", "")), "{screen}" ); assert!( lines[timeline + 2].starts_with("√ sysinit.target (2 units)"), "{screen}" ); assert!(lines[timeline + 3].starts_with("√ udev-settle"), "{screen}"); assert!(lines[timeline + 3].contains('■'), "{screen}"); assert!( lines[timeline + 4].starts_with("► systemd-rfkill"), "{screen}" ); assert!( lines[timeline + 4].contains("·■") && lines[timeline + 4].ends_with('▶'), "{screen}" ); assert!(lines[timeline + 5].starts_with("► docker"), "{screen}"); assert!( lines[timeline..].iter().all(|line| !line.contains(" web")), "{screen}" ); assert!(!screen.contains("root switch"), "{screen}"); assert!( lines[23].starts_with("√ 2 done 2 running 3 waiting × 1 failed"), "{screen}" ); } #[test] fn failures_stay_in_the_stage_that_wanted_them() { let mut state = BootState::new(Phase::Host); state.set_root("multi-user.target".to_owned()); [ facts("multi-user.target", &["basic.target", "web.service"]), facts("basic.target", &["flaky.service", "quick.service"]), facts("flaky.service", &[]), facts("quick.service", &[]), facts("web.service", &[]), ] .into_iter() .zip(1..) .for_each(|(unit, id)| { let name = unit.name.clone(); state.track_unit(unit, Activity::default()); state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO); }); state.finish_job(3, JobResult::Failed, 1000 * MS); state.finish_job(4, JobResult::Done, 1000 * MS); state.finish_job(2, JobResult::Done, 1500 * MS); let lines = render(&state, 5000 * MS, 110, 24); let screen = lines.join("\n"); assert!(lines[2].starts_with(" ├─ √ basic.target"), "{screen}"); assert!(lines[3].starts_with(" │ └─ [×] flaky"), "{screen}"); assert!( lines[4].starts_with(" └─ ◆ multi-user.target"), "{screen}" ); assert!(lines[5].starts_with(" └─ [ ] web"), "{screen}"); assert!(!screen.contains("quick"), "{screen}"); } #[test] fn finished_units_linger_in_place_before_leaving() { let mut state = BootState::new(Phase::Host); state.set_root("multi-user.target".to_owned()); [ facts("multi-user.target", &["early.service", "late.service"]), facts("early.service", &[]), facts("late.service", &[]), ] .into_iter() .zip(1..) .for_each(|(unit, id)| { let name = unit.name.clone(); let activity = if name.ends_with(".service") { running_since(Duration::ZERO) } else { Activity::default() }; state.track_unit(unit, activity); state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO); }); state.finish_job(2, JobResult::Done, 3000 * MS); let lingering = render(&state, 4000 * MS, 110, 24); let screen = lingering.join("\n"); assert!(lingering[3].starts_with(" ├─ [√] early"), "{screen}"); assert!(lingering[4].starts_with(" └─ [/] late"), "{screen}"); let gone = render(&state, 5500 * MS, 110, 24); let tree: Vec<&String> = gone .iter() .take_while(|line| !line.contains(" Timeline ")) .collect(); assert!( tree.iter().all(|line| !line.contains("early")), "{}", gone.join("\n") ); } #[test] fn only_running_units_carry_a_timer() { let lines = render(&boot_in_progress(), 12_400 * MS, 110, 24); let screen = lines.join("\n"); assert!(lines[2].ends_with("multi-user.target"), "{screen}"); assert!(lines[3].ends_with("6.4s"), "{screen}"); assert!(lines[5].ends_with("web"), "{screen}"); } const CRYPTSETUP_MESSAGE: &str = "Please enter passphrase for disk Samsung SSD 980 PRO 1TB (cryptroot):"; #[test] fn password_prompt_floats_over_a_dimmed_view() { let buffer = render_prompted( &boot_in_progress(), 12_400 * MS, 110, 24, Some(PasswordPrompt { message: CRYPTSETUP_MESSAGE, input: "***".to_owned(), sent: false, }), ); let lines = screen_lines(&buffer); let screen = lines.join("\n"); let title_row = lines .iter() .position(|line| line.contains("┌ Password ")) .unwrap_or_else(|| panic!("{screen}")); assert!(lines[title_row].starts_with(' '), "{screen}"); assert!( lines[title_row + 1].contains(&format!("│ {CRYPTSETUP_MESSAGE}")), "{screen}" ); assert!(lines[title_row + 3].contains("│ > ***_"), "{screen}"); assert!(lines[title_row + 4].contains("Enter unlock"), "{screen}"); assert!( lines[23].starts_with("√ 2 done 2 running 3 waiting × 1 failed"), "{screen}" ); assert_eq!( buffer[(0, 0)].fg, Colors::default().password.backdrop, "{screen}" ); let corner = buffer .content .iter() .find(|cell| cell.symbol() == "┌") .unwrap_or_else(|| panic!("{screen}")); assert_eq!(corner.fg, Colors::default().password.frame, "{screen}"); } #[test] fn answered_password_prompt_shows_it_is_checking() { let lines = screen_lines(&render_prompted( &boot_in_progress(), 12_400 * MS, 110, 24, Some(PasswordPrompt { message: CRYPTSETUP_MESSAGE, input: String::new(), sent: true, }), )); assert!( lines.iter().any(|line| line.contains("│ Checking…")), "{}", lines.join("\n") ); } #[test] fn long_password_messages_wrap_inside_narrow_screens() { let lines = screen_lines(&render_prompted( &boot_in_progress(), 12_400 * MS, 50, 24, Some(PasswordPrompt { message: CRYPTSETUP_MESSAGE, input: String::new(), sent: false, }), )); let screen = lines.join("\n"); assert!( lines.iter().any(|line| line.contains("(cryptroot):")), "{screen}" ); assert!(lines.iter().any(|line| line.contains("> _")), "{screen}"); } #[test] fn sub_second_runs_stay_off_the_timeline() { let mut state = boot_in_progress(); state.track_unit(facts("blink.service", &[]), running_since(4000 * MS)); state.queue_job(20, "blink.service", JobKind::BringsUp, 4000 * MS); state.finish_job(20, JobResult::Done, 4400 * MS); let lines = render(&state, 12_400 * MS, 110, 24); assert!( lines.iter().all(|line| !line.contains("blink")), "{}", lines.join("\n") ); } fn chain_boot() -> BootState { let mut state = BootState::new(Phase::Host); state.set_root("graphical.target".to_owned()); [ ("graphical.target", "network-wait.service"), ("network-wait.service", "network.target"), ("network.target", "network-manager.service"), ("network-manager.service", "dbus.service"), ("dbus.service", "udev-settle.service"), ("udev-settle.service", ""), ] .into_iter() .zip(1..) .for_each(|((name, waits_on), id)| { let after: Vec<&str> = [waits_on].into_iter().filter(|w| !w.is_empty()).collect(); let activity = if name == "udev-settle.service" { running_since(1000 * MS) } else { Activity::default() }; state.track_unit(facts(name, &after), activity); state.queue_job(id, name, JobKind::BringsUp, Duration::ZERO); }); state } #[test] fn chains_stay_unfolded_while_they_fit() { let lines = render(&chain_boot(), 5000 * MS, 110, 24); let screen = lines.join("\n"); assert!( lines[3].starts_with(" └─ [ ] network-wait"), "{screen}" ); assert!( lines[4].starts_with(" └─ network.target"), "{screen}" ); assert!( lines[7].starts_with(" └─ [/] udev-settle"), "{screen}" ); } #[test] fn chains_fold_when_short_and_shorten_to_their_ends_when_narrow() { let short = render(&chain_boot(), 5000 * MS, 110, 9); assert!( short[3] .starts_with(" └─ [ ] network-wait ─ network.target ─ network-manager ─ dbus"), "{}", short.join("\n") ); assert!( short[4].starts_with(" └─ [/] udev-settle"), "{}", short.join("\n") ); let narrow = render(&chain_boot(), 5000 * MS, 45, 8); assert!( narrow[3].starts_with(" └─ [ ] network-wait ─ … ─ dbus"), "{}", narrow.join("\n") ); } fn described_boot() -> BootState { let mut state = BootState::new(Phase::Host); state.set_root("multi-user.target".to_owned()); [ ( "multi-user.target", "Multi-User System", &["docker.service", "systemd-rfkill.service"][..], ), ("docker.service", "Docker Application Container Engine", &[]), ( "systemd-rfkill.service", "Load/Save RF Kill Switch Status", &[], ), ] .into_iter() .zip(1..) .for_each(|((name, description, after), id)| { state.track_unit( UnitFacts { description: description.to_owned(), ..facts(name, after) }, running_since(1000 * MS), ); state.queue_job(id, name, JobKind::BringsUp, Duration::ZERO); }); state } #[test] fn descriptions_line_up_in_a_column() { let lines = render(&described_boot(), 3000 * MS, 110, 24); let screen = lines.join("\n"); let column_of = |text: &str| { lines .iter() .find_map(|line| line.find(text).map(|at| line[..at].width())) .unwrap_or_else(|| panic!("{text} missing\n{screen}")) }; assert_eq!(column_of("Multi-User System"), column_of("Description")); assert_eq!( column_of("Multi-User System"), column_of("Docker Application") ); assert_eq!( column_of("Multi-User System"), column_of("Load/Save RF Kill") ); assert!(column_of("Multi-User System") > column_of("systemd-rfkill")); } #[test] fn non_service_units_carry_their_kind() { let mut state = described_boot(); state.track_unit( UnitFacts { description: "Docker Socket for the API".to_owned(), ..facts("docker.socket", &[]) }, running_since(1000 * MS), ); state.queue_job(9, "docker.socket", JobKind::BringsUp, Duration::ZERO); let lines = render(&state, 3000 * MS, 110, 24); let screen = lines.join("\n"); let socket_row = lines .iter() .find(|line| line.contains("Docker Socket")) .unwrap_or_else(|| panic!("{screen}")); assert!(socket_row.contains("[/] docker "), "{screen}"); assert!(socket_row.contains(" Socket "), "{screen}"); assert!( render(&described_boot(), 3000 * MS, 110, 24) .iter() .all(|line| !line.contains(" Socket ")), "{screen}" ); } #[test] fn narrow_screens_keep_names_and_drop_descriptions() { let lines = render(&described_boot(), 3000 * MS, 40, 24); let screen = lines.join("\n"); assert!(screen.contains("systemd-rfkill"), "{screen}"); assert!(!screen.contains("Docker"), "{screen}"); } #[test] fn long_timeline_labels_end_in_an_ellipsis() { let mut state = boot_in_progress(); state.track_unit( UnitFacts { description: "Kernel Configuration File System".to_owned(), ..facts("sys-kernel-config.mount", &[]) }, running_since(2000 * MS), ); state.queue_job(30, "sys-kernel-config.mount", JobKind::BringsUp, 2000 * MS); state.finish_job(30, JobResult::Done, 4000 * MS); let lines = render(&state, 12_400 * MS, 110, 24); assert!( lines .iter() .any(|line| line.starts_with("√ Kernel Configuration File…")), "{}", lines.join("\n") ); } #[test] fn narrow_screens_drop_the_timeline() { let lines = render(&boot_in_progress(), 12_400 * MS, 40, 24); assert!( lines.iter().all(|line| !line.contains('■')), "{}", lines.join("\n") ); assert!(lines[3].contains("systemd-rfkill"), "{}", lines.join("\n")); } #[test] fn finished_stages_collapse_into_a_summary_rule() { let mut state = BootState::new(Phase::Initrd); state.set_root("initrd.target".to_owned()); state.track_unit(facts("initrd.target", &[]), Activity::default()); state.queue_job(1, "initrd.target", JobKind::BringsUp, Duration::ZERO); state.finish_job(1, JobResult::Done, 6000 * MS); state.switch_root(7200 * MS); state.set_root("graphical.target".to_owned()); state.track_unit(facts("graphical.target", &[]), Activity::default()); state.queue_job(2, "graphical.target", JobKind::BringsUp, 7300 * MS); let lines = render(&state, 17_300 * MS, 110, 24); let screen = lines.join("\n"); assert!(lines[0].ends_with("17.3s"), "{screen}"); assert!( lines[1].starts_with("├─ Initrd ■ done in 7.2s · 1 unit"), "{screen}" ); assert!(lines[2].starts_with("└─ Stage 2 10.1s"), "{screen}"); assert!(lines[3].starts_with(" └─ ◆ graphical.target"), "{screen}"); let timeline = lines .iter() .position(|line| line.contains(" Timeline ")) .expect("timeline panel"); let initrd_bar = &lines[timeline + 2]; assert!(initrd_bar.starts_with("√ Initrd (1 unit)"), "{screen}"); assert!(initrd_bar.ends_with("■│"), "{screen}"); } #[test] fn completion_announces_the_handover() { let mut state = BootState::new(Phase::Host); state.set_root("graphical.target".to_owned()); state.track_unit(facts("graphical.target", &[]), Activity::default()); state.queue_job(1, "graphical.target", JobKind::BringsUp, Duration::ZERO); state.finish_job(1, JobResult::Done, 9000 * MS); let lines = render(&state, 9500 * MS, 110, 24); assert!( lines[1].starts_with( "└─ ■ Boot finished in 9.5s · handing over to display-manager.service" ), "{}", lines.join("\n") ); } #[test] fn shutdown_in_progress_names_its_stage() { let mut state = BootState::new(Phase::Shutdown); state.origin = 20_000 * MS; state.set_root("poweroff.target".to_owned()); state.track_unit(facts("poweroff.target", &[]), Activity::default()); state.queue_job(1, "poweroff.target", JobKind::BringsUp, 20_000 * MS); let lines = render(&state, 21_500 * MS, 110, 24); assert!( lines[1].starts_with("└─ Shutdown 1.5s") && lines[1].ends_with("Running"), "{}", lines.join("\n") ); } #[test] fn shutdown_announces_the_handover_once_the_manager_exits() { let mut state = BootState::new(Phase::Shutdown); state.origin = 20_000 * MS; state.manager_exited_at = Some(24_200 * MS); let lines = render(&state, 30_000 * MS, 110, 24); assert!( lines[1] .starts_with("└─ ■ Shutdown finished in 4.2s · handing over to systemd-shutdown"), "{}", lines.join("\n") ); } #[test] fn the_tree_takes_the_room_and_the_timeline_only_what_is_left() { let heights = Heights::share(30, 40, 50); assert_eq!((heights.tree, heights.timeline), (30, 0)); let heights = Heights::share(30, 12, 50); assert_eq!((heights.tree, heights.timeline), (12, 18)); let heights = Heights::share(30, 25, 50); assert_eq!((heights.tree, heights.timeline), (30, 0)); let heights = Heights::share(30, 12, 8); assert_eq!((heights.tree, heights.timeline), (22, 8)); } #[test] fn the_timeline_keeps_only_the_slowest_finished_runs() { let mut state = BootState::new(Phase::Host); state.set_root("multi-user.target".to_owned()); let quick_units: Vec = (0..10).map(|n| format!("run{n:02}.service")).collect(); let after: Vec<&str> = quick_units .iter() .map(String::as_str) .chain(["slow.service"]) .collect(); state.track_unit(facts("multi-user.target", &after), Activity::default()); state.queue_job(100, "multi-user.target", JobKind::BringsUp, Duration::ZERO); state.track_unit(facts("slow.service", &[]), running_since(Duration::ZERO)); state.queue_job(101, "slow.service", JobKind::BringsUp, Duration::ZERO); quick_units.iter().zip(0..).for_each(|(name, id)| { state.track_unit(facts(name, &[]), running_since(Duration::ZERO)); state.queue_job(id, name, JobKind::BringsUp, Duration::ZERO); state.finish_job(id, JobResult::Done, (1000 + 1000 * id) * MS); }); let lines = render(&state, 20_000 * MS, 110, 40); let screen = lines.join("\n"); let timeline = lines .iter() .position(|line| line.contains(" Timeline ")) .expect("timeline panel"); let (tree, panel) = lines.split_at(timeline); assert!(tree.iter().all(|line| !line.contains('…')), "{screen}"); let shown: Vec<&str> = quick_units .iter() .map(|name| name.trim_end_matches(".service")) .filter(|label| panel.iter().any(|line| line.contains(label))) .collect(); assert_eq!( shown, ["run05", "run06", "run07", "run08", "run09"], "{screen}" ); } #[test] fn overflowing_trees_are_cut_with_a_count() { let mut state = BootState::new(Phase::Host); (0..30).for_each(|id| { let name = format!("unit{id:02}.service"); state.track_unit(facts(&name, &[]), Activity::default()); state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO); }); let lines = render(&state, 1000 * MS, 110, 20); assert!( lines.iter().any(|line| line.starts_with(" … ")), "{}", lines.join("\n") ); } }