//! Hardware-free tests for the [`crate::docker::health`] collection //! model (verdict assembly, sweep parsing, summary building). use super::collect::{build_summary, net_check_script, parse_ps_output, verdict_for}; use super::{HealthReport, NodeHealth, RecipesSummary}; use crate::cluster_state::ClusterVerdict; use crate::config::{Cluster, Node}; use crate::home_assistant::EntityStates; fn node(name: &str, online: bool, containers: &[&str]) -> NodeHealth { NodeHealth { name: name.into(), ib_ip: "10.0.0.1".into(), online, containers: containers.iter().map(|s| (*s).to_string()).collect(), net_up: true, net_details: vec![], } } fn test_cluster(name: &str, node_names: &[&str]) -> Cluster { Cluster { name: name.into(), master_ib_ip: None, nodes: node_names .iter() .enumerate() .map(|(i, n)| Node { name: (*n).to_string(), ssh_ip: format!("10.0.0.{i}"), ib_ip: None, rank: i as u32, host_key: None, entity: None, }) .collect(), extra_entities: vec![], } } fn report(cluster: &str, switch_off: bool) -> HealthReport { HealthReport { cluster: cluster.into(), verdict: ClusterVerdict { up: true, switch_off, free: 0, }, soft_off: vec![], nodes: vec![], tmux: vec![], } } #[test] fn verdict_all_online_counts_free() { let nodes = vec![node("a", true, &[]), node("b", true, &["c1"])]; let v = verdict_for(&nodes, false); assert_eq!( v, ClusterVerdict { up: true, switch_off: false, free: 1 } ); } #[test] fn verdict_offline_node_downs_cluster() { let nodes = vec![node("a", true, &["c1"]), node("b", false, &[])]; let v = verdict_for(&nodes, false); assert!(!v.up); assert_eq!(v.free, 0); } #[test] fn verdict_from_entity_states_switch_off_downs_cluster() { let nodes = vec![node("a", true, &[]), node("b", true, &["c1"])]; let es = EntityStates { blocking_off: true, soft_off: vec!["switch.fan".into()], }; let v = verdict_for(&nodes, es.blocking_off); assert!(!v.up && v.switch_off && v.free == 0); } #[test] fn parse_ps_output_splits_containers_and_net() { let out = "sm121_ds4_0\tUp 2 hours\timg:tag\n\ \n\ sudo: permission denied\n\ docker: error line\n\ ---NET---\n\ socket:UP\n\ ---END---\n"; let (containers, net_up, details) = parse_ps_output(out); assert_eq!(containers, vec!["sm121_ds4_0\tUp 2 hours\timg:tag"]); assert!(net_up); assert_eq!(details, vec!["socket:UP"]); } #[test] fn parse_ps_output_down_missing_error_flip_net_up() { for tail in ["socket:DOWN", "socket:missing", "socket:error"] { let out = format!("---NET---\n{tail}\n---END---\n"); assert!(!parse_ps_output(&out).1, "{tail} must flip net_up"); } } #[test] fn net_check_script_validates_interface_name() { assert!(net_check_script(Some("eth0")).is_some()); assert!(net_check_script(Some("enp2s0.100")).is_some()); assert!(net_check_script(Some("ib-weird_1")).is_some()); assert!(net_check_script(Some("bad;rm -rf")).is_none()); assert!(net_check_script(None).is_none()); } #[tokio::test] async fn build_summary_excludes_down_clusters_and_sorts_nodes() { let clusters = vec![ test_cluster("up", &["n0", "n0b"]), test_cluster("down", &["n1"]), ]; // Sweep: both "up" nodes reachable with ds4|up; "down" node unreachable. let sweep: Vec)>> = vec![ tokio::spawn(async { ("n0".into(), Ok("ds4|up".into())) }), tokio::spawn(async { ("n0b".into(), Ok("ds4|up".into())) }), tokio::spawn(async { ("n1".into(), Err(anyhow::anyhow!("ssh down"))) }), ]; let reports = vec![report("up", false), report("down", false)]; let summary: RecipesSummary = build_summary(&clusters, &reports, sweep).await; assert_eq!( summary.by_recipe["ds4"]["up"], vec!["n0".to_string(), "n0b".to_string()] ); assert!(!summary.by_recipe["ds4"].contains_key("down")); } /// Renderer tests for [`super::render`] — plain, markdown, and HTML — /// reusing the collection-model fixtures above. mod render { use std::collections::HashMap; use super::super::FleetHealth; use super::super::render::render_fleet; use super::{HealthReport, RecipesSummary, node, report}; use crate::cli::OutputFormat; use crate::tmux::discover::TmuxHealthEntry; fn fleet(clusters: Vec, recipes: Option) -> FleetHealth { FleetHealth { clusters, recipes } } fn container(name: &str, status: &str, image: &str) -> String { format!("{name}\t{status}\t{image}") } fn up_report() -> HealthReport { let mut r = report("c1", false); r.nodes = vec![node( "n0", true, &[&container("app", "Up 2 hours", "img:tag")], )]; r } fn down_report() -> HealthReport { let mut r = report("down", false); r.verdict.up = false; r.verdict.free = 0; r.nodes = vec![ node("alive", true, &[&container("secret", "Up", "img")]), node("dead", false, &[]), ]; r } fn tmux_entry(recipe: &str, node_name: &str, session: bool, running: bool) -> TmuxHealthEntry { TmuxHealthEntry { recipe_display: recipe.into(), node_name: node_name.into(), session_exists: session, process_running: running, api_ok: true, } } fn tmux_report(entries: Vec) -> HealthReport { let mut r = report("c1", false); r.tmux = entries; r } #[test] fn render_fleet_handles_each_format() { let f = fleet(vec![up_report()], None); let plain = render_fleet(&f, OutputFormat::Plain); let md = render_fleet(&f, OutputFormat::Md); let html = render_fleet(&f, OutputFormat::Html); assert!(plain.contains("=== c1 ===")); // Container columns parsed out of the tab-separated lines. assert!(plain.contains("app Up 2 hours img:tag")); assert!(!plain.contains('\t'), "plain must not emit raw tab blobs"); assert!(md.contains("## c1")); assert!(html.contains("

c1

")); assert_ne!(plain, md); } #[test] fn html_escapes_hostile_names() { let mut r = report("a&\"c'", false); r.nodes = vec![node( "