Struct WaitProgress 

pub struct WaitProgress { /* private fields */ }

Tracks one poll-until-ready loop: owns the clock, counts probes, and emits a throttled heartbeat line.

Construct it just before the loop, then per iteration use timed_out for the bound and tick to count the probe and print a heartbeat when due:

let mut progress = WaitProgress::new("vikunja", "systemctl + healthcheck", timeout)
    .with_prefix(format!("[{test_name}]     "));
loop {
    if ready { return Ok(()); }
    if failed { bail!("..."); }
    if progress.timed_out() { bail!("not ready after {}s", timeout.as_secs()); }
    progress.tick();
    tokio::time::sleep(interval).await;
}

Implementations

impl WaitProgress

pub fn new( label: impl Into<String>, method: impl Into<String>, timeout: Duration, ) -> Self

label is what we’re waiting for; method describes how readiness is probed; the loop is bounded by timeout. Defaults to a two-space prefix and a 5s heartbeat cadence — override with with_prefix / with_heartbeat.

pub fn with_prefix(self, prefix: impl Into<String>) -> Self

Set the line prefix so the heartbeat aligns with the surrounding output (e.g. "[my-test] "). Defaults to two spaces.

pub fn with_heartbeat(self, every: Duration) -> Self

Override how often a heartbeat prints. Defaults to 5s — right for the short service/port waits; long VM boot/SSH waits set this to 30s so they don’t flood the log.

pub fn elapsed(&self) -> Duration

Time since the loop started.

pub fn timed_out(&self) -> bool

Whether the loop has run past its timeout.

pub fn tick(&mut self)

Record one probe attempt and print a heartbeat line if the cadence is due. Call once per loop iteration.