refactor: split model and view into files under 500 lines
This commit is contained in:
1 parent
4c8268a719
commit
589cc3c82b
10 files changed
+1744
-1655
No files matched your search
+6
-604
@@ -1,7 +1,13 @@
|
||||
#[cfg(test)]
|
||||
mod panel_render_tests;
|
||||
mod run_timeline;
|
||||
mod screen_chrome;
|
||||
#[cfg(test)]
|
||||
mod screen_render_fixtures;
|
||||
mod stage_summary;
|
||||
mod tree_height_fitting;
|
||||
#[cfg(test)]
|
||||
mod tree_render_tests;
|
||||
mod unit_tree;
|
||||
|
||||
use std::time::Duration;
|
||||
@@ -233,550 +239,7 @@ fn unit_count(count: usize) -> String {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use ratatui::{Terminal, backend::TestBackend};
|
||||
|
||||
use super::*;
|
||||
use crate::{
|
||||
boot_model::{JobResult, Phase},
|
||||
boot_test_fixtures::{MS, queue_unit, queued_boot, running, waiting},
|
||||
};
|
||||
|
||||
fn render(state: &BootState, now: Duration, width: u16, height: u16) -> Vec<String> {
|
||||
screen_lines(&render_prompted(state, now, width, height, None))
|
||||
}
|
||||
|
||||
fn render_prompted(
|
||||
state: &BootState,
|
||||
now: Duration,
|
||||
width: u16,
|
||||
height: u16,
|
||||
password_prompt: Option<PasswordPrompt>,
|
||||
) -> 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<String> {
|
||||
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 boot_in_progress() -> BootState {
|
||||
let mut state = queued_boot(
|
||||
Phase::Host,
|
||||
1000 * MS,
|
||||
[
|
||||
waiting("graphical.target", &["multi-user.target"]),
|
||||
waiting(
|
||||
"multi-user.target",
|
||||
&["docker.service", "systemd-rfkill.service", "web.service"],
|
||||
),
|
||||
running("docker.service", &[], 9000 * MS),
|
||||
running("systemd-rfkill.service", &[], 6000 * MS),
|
||||
waiting("web.service", &[]),
|
||||
waiting("sysinit.target", &[]),
|
||||
waiting("nvidia-powerd.service", &[]),
|
||||
running("udev-settle.service", &[], 2000 * 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 = queued_boot(
|
||||
Phase::Host,
|
||||
Duration::ZERO,
|
||||
[
|
||||
waiting("multi-user.target", &["basic.target", "web.service"]),
|
||||
waiting("basic.target", &["flaky.service", "quick.service"]),
|
||||
waiting("flaky.service", &[]),
|
||||
waiting("quick.service", &[]),
|
||||
waiting("web.service", &[]),
|
||||
],
|
||||
);
|
||||
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 = queued_boot(
|
||||
Phase::Host,
|
||||
Duration::ZERO,
|
||||
[
|
||||
waiting("multi-user.target", &["early.service", "late.service"]),
|
||||
running("early.service", &[], Duration::ZERO),
|
||||
running("late.service", &[], 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();
|
||||
queue_unit(
|
||||
&mut state,
|
||||
20,
|
||||
running("blink.service", &[], 4000 * MS),
|
||||
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 {
|
||||
queued_boot(
|
||||
Phase::Host,
|
||||
Duration::ZERO,
|
||||
[
|
||||
waiting("graphical.target", &["network-wait.service"]),
|
||||
waiting("network-wait.service", &["network.target"]),
|
||||
waiting("network.target", &["network-manager.service"]),
|
||||
waiting("network-manager.service", &["dbus.service"]),
|
||||
waiting("dbus.service", &["udev-settle.service"]),
|
||||
running("udev-settle.service", &[], 1000 * MS),
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
#[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 {
|
||||
queued_boot(
|
||||
Phase::Host,
|
||||
Duration::ZERO,
|
||||
[
|
||||
running(
|
||||
"multi-user.target",
|
||||
&["docker.service", "systemd-rfkill.service"],
|
||||
1000 * MS,
|
||||
)
|
||||
.described("Multi-User System"),
|
||||
running("docker.service", &[], 1000 * MS)
|
||||
.described("Docker Application Container Engine"),
|
||||
running("systemd-rfkill.service", &[], 1000 * MS)
|
||||
.described("Load/Save RF Kill Switch Status"),
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
#[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();
|
||||
queue_unit(
|
||||
&mut state,
|
||||
9,
|
||||
running("docker.socket", &[], 1000 * MS).described("Docker Socket for the API"),
|
||||
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();
|
||||
queue_unit(
|
||||
&mut state,
|
||||
30,
|
||||
running("sys-kernel-config.mount", &[], 2000 * MS)
|
||||
.described("Kernel Configuration File System"),
|
||||
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 = queued_boot(
|
||||
Phase::Initrd,
|
||||
Duration::ZERO,
|
||||
[waiting("initrd.target", &[])],
|
||||
);
|
||||
state.finish_job(1, JobResult::Done, 6000 * MS);
|
||||
state.switch_root(7200 * MS);
|
||||
state.set_root("graphical.target".to_owned());
|
||||
queue_unit(&mut state, 2, waiting("graphical.target", &[]), 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 = queued_boot(
|
||||
Phase::Host,
|
||||
Duration::ZERO,
|
||||
[waiting("graphical.target", &[])],
|
||||
);
|
||||
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 = queued_boot(
|
||||
Phase::Shutdown,
|
||||
20_000 * MS,
|
||||
[waiting("poweroff.target", &[])],
|
||||
);
|
||||
state.origin = 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() {
|
||||
@@ -789,65 +252,4 @@ mod tests {
|
||||
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 quick_units: Vec<String> = (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();
|
||||
let mut state = queued_boot(
|
||||
Phase::Host,
|
||||
Duration::ZERO,
|
||||
[
|
||||
waiting("multi-user.target", &after),
|
||||
running("slow.service", &[], Duration::ZERO),
|
||||
],
|
||||
);
|
||||
quick_units.iter().zip(10..).for_each(|(name, id)| {
|
||||
queue_unit(
|
||||
&mut state,
|
||||
id,
|
||||
running(name, &[], Duration::ZERO),
|
||||
Duration::ZERO,
|
||||
);
|
||||
state.finish_job(id, JobResult::Done, (1000 * id - 9000) * 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 names: Vec<String> = (0..30).map(|id| format!("unit{id:02}.service")).collect();
|
||||
let state = queued_boot(
|
||||
Phase::Host,
|
||||
Duration::ZERO,
|
||||
names.iter().map(|name| waiting(name, &[])),
|
||||
);
|
||||
let lines = render(&state, 1000 * MS, 110, 20);
|
||||
assert!(
|
||||
lines.iter().any(|line| line.starts_with(" … ")),
|
||||
"{}",
|
||||
lines.join("\n")
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user