From c5687a73916284adda3b253c32480d84ef989e5f Mon Sep 17 00:00:00 2001 From: Marc Seiler Date: Thu, 8 Oct 2026 16:48:58 -0400 Subject: [PATCH] feat(progress): per-server progress bars and transfer log - add indicatif-based progress bars, one per server, sharing a MultiProgress; enabled only for text output on an interactive terminal - route log output above the bars so lines are not overwritten - add a --fancy flag (default true) to disable bars - always write a plain-text transfer log next to each archive (.log) with the server, totals and every transferred file so details remain available while bars are shown --- Cargo.lock | 60 +++++++++++ Cargo.toml | 1 + README.md | 16 +++ src/backup/manager.rs | 57 +++++++++- src/backup/mod.rs | 2 +- src/cli/backup.rs | 20 +++- src/cli/mod.rs | 50 ++++++++- src/progress.rs | 236 +++++++++++++++++++++++++++++++++++++++++- 8 files changed, 427 insertions(+), 15 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index df978e8..975d3a5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -185,6 +185,18 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" +[[package]] +name = "console" +version = "0.16.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e96a4956774c13c126a8b5af4daa79384f4d826534c95a02d76afb39e2ab64e3" +dependencies = [ + "encode_unicode", + "libc", + "unicode-width", + "windows-sys 0.61.2", +] + [[package]] name = "cookie" version = "0.18.2" @@ -277,6 +289,12 @@ version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + [[package]] name = "equivalent" version = "1.0.2" @@ -405,6 +423,7 @@ dependencies = [ "clap", "dotenvy", "flate2", + "indicatif", "regex", "schemars", "serde", @@ -583,6 +602,19 @@ dependencies = [ "hashbrown", ] +[[package]] +name = "indicatif" +version = "0.18.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9433806cd6b4ec1aba79c021c7e4c58fb4c3b9977c085062e611ac929998fb0c" +dependencies = [ + "console", + "portable-atomic", + "unicode-width", + "unit-prefix", + "web-time", +] + [[package]] name = "is_terminal_polyfill" version = "1.70.2" @@ -838,6 +870,12 @@ version = "0.3.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + [[package]] name = "potential_utf" version = "0.1.6" @@ -1329,6 +1367,18 @@ version = "1.0.26" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + +[[package]] +name = "unit-prefix" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3" + [[package]] name = "unsafe-libyaml" version = "0.2.11" @@ -1466,6 +1516,16 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + [[package]] name = "webpki-roots" version = "1.0.9" diff --git a/Cargo.toml b/Cargo.toml index f7ff22b..0780223 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -42,6 +42,7 @@ chrono = { version = "0.4", default-features = false, features = ["clock", "std" clap = { version = "4", features = ["derive"] } dotenvy = "0.15" flate2 = "1" +indicatif = "0.18" regex = "1" schemars = { version = "1", features = ["derive"] } serde = { version = "1", features = ["derive"] } diff --git a/README.md b/README.md index af54a0b..218f3e2 100644 --- a/README.md +++ b/README.md @@ -89,9 +89,25 @@ gsbt backup --quiet - `--verbose` / `-v` – Enable debug logging and show metadata - `--quiet` / `-q` – Only show errors - `--sequential` – Run backups one server at a time (default is parallel) +- `--fancy ` – Show fancy per-server progress bars when the terminal supports it (default `true`; use `--fancy=false` to disable) Archives are stored at `{backup_location}/{timestamp}.tar.gz` with temp files under `{backup_location}/.tmp/`. +When running on an interactive terminal, each server gets its own progress bar (they are not shown when output is piped, in `--quiet`/`--output json` mode, or with `--fancy=false`). A plain-text transfer log is always written next to each archive at `{backup_location}/{timestamp}.log`, listing the server, totals, and every transferred file, so the details remain available even while bars are drawn. + +```text +# example transfer log +# gsbt transfer log +server: my-ftp +archive: /srv/backups/my-ftp/2026-01-15_154500.tar.gz +files: 5 +bytes: 2400000 +duration_sec: 3.201 +--- +saves/world.dat 1200000 +config/server.ini 10240 +``` + ### Output Modes **Text mode** (default): diff --git a/src/backup/manager.rs b/src/backup/manager.rs index 4118d7d..a2949af 100644 --- a/src/backup/manager.rs +++ b/src/backup/manager.rs @@ -2,13 +2,13 @@ use std::fs::{self, File}; use std::io::{self, Write}; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::time::{Duration, Instant}; use anyhow::{bail, Context, Result}; use crate::backup::archive::{create_archive, timestamped_filename}; -use crate::connector::Connector; +use crate::connector::{Connector, FileInfo}; use crate::progress::Reporter; /// Summary of a backup run. @@ -26,6 +26,7 @@ pub struct Stats { pub struct Manager { pub temp_dir: String, pub backup_location: String, + pub server_name: String, pub progress: Reporter, } @@ -110,10 +111,51 @@ impl Manager { create_archive(Path::new(&temp_dir), &archive_path).context("create archive")?; stats.duration = start.elapsed(); - Ok((archive_path.to_string_lossy().into_owned(), stats)) + + let archive_path = archive_path.to_string_lossy().into_owned(); + // Best-effort: write a readable transfer log next to the archive so the + // per-file details remain available even when a progress bar is shown. + let log_path = transfer_log_path(&archive_path); + let _ = write_transfer_log(&log_path, &self.server_name, &archive_path, &files, &stats); + + Ok((archive_path, stats)) + } +} + +/// Returns the transfer-log path for an archive +/// (`foo.tar.gz` becomes `foo.log`, next to the archive). +pub fn transfer_log_path(archive_path: &str) -> PathBuf { + match archive_path.strip_suffix(".tar.gz") { + Some(base) => PathBuf::from(format!("{base}.log")), + None => Path::new(archive_path).with_extension("log"), } } +fn write_transfer_log( + log_path: &Path, + server: &str, + archive_path: &str, + files: &[FileInfo], + stats: &Stats, +) -> io::Result<()> { + let mut file = File::create(log_path)?; + writeln!(file, "# gsbt transfer log")?; + writeln!(file, "server: {server}")?; + writeln!(file, "archive: {archive_path}")?; + writeln!(file, "files: {}", stats.files)?; + writeln!(file, "bytes: {}", stats.bytes)?; + writeln!(file, "duration_sec: {:.3}", stats.duration.as_secs_f64())?; + writeln!(file, "---")?; + + for entry in files { + if !entry.is_dir { + writeln!(file, "{}\t{}", entry.path, entry.size)?; + } + } + + Ok(()) +} + /// Wraps a writer to report incremental bytes written. struct ProgressWriter<'a> { inner: &'a mut dyn Write, @@ -212,6 +254,7 @@ mod tests { let mut manager = Manager { temp_dir: String::new(), backup_location: tmp.path().to_string_lossy().into_owned(), + server_name: "test-server".to_string(), progress: crate::progress::new(&crate::log::Logger::new(), "json"), }; @@ -221,6 +264,13 @@ mod tests { assert_eq!(Path::new(&archive_path).parent().unwrap(), tmp.path()); assert_eq!(stats.files, 2); assert_eq!(stats.bytes, ("hello".len() + "world".len()) as i64); + + // A transfer log is written next to the archive. + let log_path = transfer_log_path(&archive_path); + let log = std::fs::read_to_string(&log_path).expect("transfer log"); + assert!(log.contains("server: test-server")); + assert!(log.contains("file1.txt")); + assert!(log.contains("nested/file2.txt")); } #[test] @@ -229,6 +279,7 @@ mod tests { let mut manager = Manager { temp_dir: String::new(), backup_location: String::new(), + server_name: "test-server".to_string(), progress: crate::progress::new(&crate::log::Logger::new(), "json"), }; assert!(manager.backup(&mut conn).is_err()); diff --git a/src/backup/mod.rs b/src/backup/mod.rs index aaf3195..8c8bb4c 100644 --- a/src/backup/mod.rs +++ b/src/backup/mod.rs @@ -4,4 +4,4 @@ pub mod archive; pub mod manager; pub use archive::{create_archive, timestamped_filename}; -pub use manager::{Manager, Stats}; +pub use manager::{transfer_log_path, Manager, Stats}; diff --git a/src/cli/backup.rs b/src/cli/backup.rs index eb0c9ea..622c968 100644 --- a/src/cli/backup.rs +++ b/src/cli/backup.rs @@ -21,7 +21,12 @@ pub struct BackupOptions { } /// Runs the backup command using the supplied connector factory. -pub fn run_backup(opts: &BackupOptions, logger: &Logger, factory: &ConnectorFactory) -> Result<()> { +pub fn run_backup( + opts: &BackupOptions, + logger: &Logger, + progress_factory: &progress::ProgressFactory, + factory: &ConnectorFactory, +) -> Result<()> { let cfg_path = crate::config::find_config_file(&opts.config)?; let cfg = crate::config::load_config(&cfg_path)?; @@ -36,8 +41,6 @@ pub fn run_backup(opts: &BackupOptions, logger: &Logger, factory: &ConnectorFact bail!("no servers configured"); } - let format = opts.output.as_str(); - let run_one = |server: &Server| -> bool { let server_logger = logger.with_prefix(format!("[bold][cyan]{}[/cyan][/bold]", server.name)); @@ -62,21 +65,26 @@ pub fn run_backup(opts: &BackupOptions, logger: &Logger, factory: &ConnectorFact let mut manager = Manager { backup_location: server.get_backup_location(&cfg.defaults), temp_dir: cfg.defaults.temp_dir.clone(), - progress: progress::new(&server_logger, format), + server_name: server.name.clone(), + progress: progress_factory.reporter(&server_logger, &server.name), }; let start = Instant::now(); match manager.backup(&mut *conn) { Ok((archive_path, stats)) => { + let log_path = crate::backup::transfer_log_path(&archive_path) + .to_string_lossy() + .into_owned(); server_logger.info_with( format!( - "[green]saved[/green] {archive_path} ({} files, {:.1} MB, {:.1}s)", + "[green]saved[/green] {archive_path} ({} files, {:.1} MB, {:.1}s); log: {log_path}", stats.files, stats.bytes as f64 / 1e6, start.elapsed().as_secs_f64() ), crate::meta! { "archive_path" => archive_path, + "log_path" => log_path, "files" => stats.files, "bytes" => stats.bytes, "duration_sec" => start.elapsed().as_secs_f64(), @@ -120,6 +128,8 @@ pub fn run_backup(opts: &BackupOptions, logger: &Logger, factory: &ConnectorFact ) }; + progress_factory.finish(); + if failures > 0 { bail!("backup complete with failures: {successes} success, {failures} failed"); } diff --git a/src/cli/mod.rs b/src/cli/mod.rs index 1d286ce..4b9a01d 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -4,7 +4,7 @@ pub mod backup; pub mod restore; use std::fs; -use std::io::Write; +use std::io::{IsTerminal, Write}; use std::path::Path; use anyhow::{bail, Context, Result}; @@ -12,6 +12,7 @@ use clap::{CommandFactory, Parser, Subcommand}; use crate::connector::{Config as ConnectorConfig, Connector}; use crate::log::Logger; +use crate::progress; use backup::BackupOptions; use restore::RestoreCliArgs; @@ -74,6 +75,15 @@ pub enum Commands { /// run backups sequentially #[arg(long)] sequential: bool, + /// show fancy progress bars (use --fancy=false to disable) + #[arg( + long, + default_value_t = true, + action = clap::ArgAction::Set, + num_args = 0..=1, + default_missing_value = "true" + )] + fancy: bool, }, /// Remove old backups #[command( @@ -151,11 +161,13 @@ pub enum Commands { /// Parses CLI arguments and executes the requested command. pub fn run() -> Result<()> { let cli = Cli::parse(); + let interactive = std::io::stdout().is_terminal() && std::io::stderr().is_terminal(); execute( &cli, &crate::connector::new_connector, Box::new(std::io::stdout()), Box::new(std::io::stderr()), + interactive, ) } @@ -166,6 +178,7 @@ pub fn execute( factory: &ConnectorFactory, mut out: Box, err: Box, + interactive: bool, ) -> Result<()> { if cli.verbose && cli.quiet { bail!("--verbose and --quiet flags cannot be used together"); @@ -221,7 +234,15 @@ pub fn execute( }; restore::run_restore(&args, &logger, factory) } - Some(Commands::Backup { server, sequential }) => { + Some(Commands::Backup { + server, + sequential, + fancy, + }) => { + let progress_factory = + progress::ProgressFactory::new(&cli.output, cli.quiet, interactive && *fancy); + let (out, err) = progress_factory.wrap_writers(out, err); + let mut logger = Logger::with_writers(out, err); logger.set_output_format(&cli.output); logger.set_quiet(cli.quiet); @@ -233,7 +254,7 @@ pub fn execute( server: server.clone(), sequential: *sequential, }; - backup::run_backup(&opts, &logger, factory) + backup::run_backup(&opts, &logger, &progress_factory, factory) } } } @@ -381,7 +402,13 @@ mod tests { let cli = Cli::try_parse_from(args).expect("parse args"); let out = BufferWriter::new(); let err = BufferWriter::new(); - let result = execute(&cli, factory, Box::new(out.clone()), Box::new(err.clone())); + let result = execute( + &cli, + factory, + Box::new(out.clone()), + Box::new(err.clone()), + false, + ); let mut combined = out.contents(); combined.push_str(&err.contents()); (result, combined) @@ -404,6 +431,21 @@ mod tests { assert!(!cli.quiet); } + #[test] + fn backup_fancy_flag_parses() { + let default = Cli::try_parse_from(["gsbt", "backup"]).expect("parse"); + assert!(matches!( + default.command, + Some(Commands::Backup { fancy: true, .. }) + )); + + let disabled = Cli::try_parse_from(["gsbt", "backup", "--fancy=false"]).expect("parse"); + assert!(matches!( + disabled.command, + Some(Commands::Backup { fancy: false, .. }) + )); + } + #[test] fn verbose_and_quiet_conflict() { let factory = factory_with(Duration::ZERO); diff --git a/src/progress.rs b/src/progress.rs index ef7a60e..d5aa318 100644 --- a/src/progress.rs +++ b/src/progress.rs @@ -1,4 +1,15 @@ //! Progress reporting for long-running operations. +//! +//! Three reporters are available: +//! - [`Reporter::Null`] - no output (quiet/JSON modes). +//! - [`Reporter::Simple`] - one informational line per event (piped output). +//! - [`Reporter::Bar`] - an `indicatif` progress bar, one per server, used +//! when the terminal supports it. + +use std::io::{self, Write}; +use std::time::Duration; + +use indicatif::{MultiProgress, ProgressBar, ProgressStyle}; use crate::log::Logger; @@ -6,8 +17,10 @@ use crate::log::Logger; pub enum Reporter { /// No-op reporter used for quiet and JSON output modes. Null(NullProgress), - /// Text-based reporter used for the default output mode. + /// Text-based reporter used when output is not a terminal. Simple(SimpleProgress), + /// `indicatif` progress bar used when the terminal supports it. + Bar(BarProgress), } impl Reporter { @@ -16,6 +29,7 @@ impl Reporter { match self { Reporter::Null(p) => p.start(total_bytes, file_count), Reporter::Simple(p) => p.start(total_bytes, file_count), + Reporter::Bar(p) => p.start(total_bytes, file_count), } } @@ -24,6 +38,7 @@ impl Reporter { match self { Reporter::Null(p) => p.file_start(name, size), Reporter::Simple(p) => p.file_start(name, size), + Reporter::Bar(p) => p.file_start(name, size), } } @@ -32,6 +47,7 @@ impl Reporter { match self { Reporter::Null(p) => p.file_progress(name, written, size), Reporter::Simple(p) => p.file_progress(name, written, size), + Reporter::Bar(p) => p.file_progress(name, written, size), } } @@ -40,6 +56,7 @@ impl Reporter { match self { Reporter::Null(p) => p.file_done(name), Reporter::Simple(p) => p.file_done(name), + Reporter::Bar(p) => p.file_done(name), } } @@ -48,6 +65,7 @@ impl Reporter { match self { Reporter::Null(p) => p.message(msg), Reporter::Simple(p) => p.message(msg), + Reporter::Bar(p) => p.message(msg), } } @@ -56,11 +74,15 @@ impl Reporter { match self { Reporter::Null(p) => p.close(), Reporter::Simple(p) => p.close(), + Reporter::Bar(p) => p.close(), } } } -/// Creates a progress reporter based on the output format. +/// Creates a simple reporter based on the output format (no bars). +/// +/// Prefer [`ProgressFactory`] in the CLI, which enables bars when the terminal +/// supports them. pub fn new(logger: &Logger, format: &str) -> Reporter { if logger.is_quiet() || format == "json" { Reporter::Null(NullProgress) @@ -69,6 +91,90 @@ pub fn new(logger: &Logger, format: &str) -> Reporter { } } +/// Creates per-server reporters, sharing a single multi-progress when enabled. +pub struct ProgressFactory { + multi: Option, + format: String, +} + +impl ProgressFactory { + /// Creates a factory. Bars are only enabled for text output on a terminal + /// when not in quiet mode. + pub fn new(format: &str, quiet: bool, terminal: bool) -> Self { + let enabled = format == "text" && !quiet && terminal; + Self { + multi: enabled.then(MultiProgress::new), + format: format.to_string(), + } + } + + /// Returns `true` when bars are enabled. + pub fn is_enabled(&self) -> bool { + self.multi.is_some() + } + + /// Creates a reporter for a single server. + pub fn reporter(&self, logger: &Logger, server: &str) -> Reporter { + match &self.multi { + Some(multi) => Reporter::Bar(BarProgress::new(multi, server)), + None => new(logger, &self.format), + } + } + + /// Wraps the log writers so output is printed above the bars instead of + /// being overwritten by them. + pub fn wrap_writers( + &self, + out: Box, + err: Box, + ) -> (Box, Box) { + match &self.multi { + Some(multi) => ( + Box::new(MultiProgressWriter::new(multi.clone())), + Box::new(MultiProgressWriter::new(multi.clone())), + ), + None => (out, err), + } + } + + /// Clears any remaining bars once the run has finished. + pub fn finish(&self) { + if let Some(multi) = &self.multi { + let _ = multi.clear(); + } + } +} + +/// A writer that forwards whole lines to a [`MultiProgress`] so log output +/// does not corrupt the bars. +#[derive(Clone)] +struct MultiProgressWriter { + multi: MultiProgress, +} + +impl MultiProgressWriter { + fn new(multi: MultiProgress) -> Self { + Self { multi } + } +} + +impl Write for MultiProgressWriter { + fn write(&mut self, buf: &[u8]) -> io::Result { + let text = String::from_utf8_lossy(buf); + for line in text.split_inclusive('\n') { + let line = line.trim_end_matches(['\n', '\r']); + if !line.is_empty() { + let _ = self.multi.println(line); + } + } + Ok(buf.len()) + } + + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + /// No-op reporter for quiet/JSON modes. pub struct NullProgress; @@ -117,6 +223,94 @@ impl SimpleProgress { pub fn close(&self) {} } +/// `indicatif`-based progress bar, one per server. +pub struct BarProgress { + bar: ProgressBar, + total_bytes: u64, + completed_bytes: u64, + current_file_size: u64, + total_files: usize, + files_done: usize, +} + +impl BarProgress { + fn new(multi: &MultiProgress, server: &str) -> Self { + let bar = multi.add(ProgressBar::new(0)); + bar.set_style(bar_style()); + bar.set_prefix(truncate(server, 20)); + bar.enable_steady_tick(Duration::from_millis(100)); + Self { + bar, + total_bytes: 0, + completed_bytes: 0, + current_file_size: 0, + total_files: 0, + files_done: 0, + } + } + + pub fn start(&mut self, total_bytes: i64, file_count: usize) { + self.total_bytes = total_bytes.max(0) as u64; + self.total_files = file_count; + self.bar.set_length(self.total_bytes); + self.set_files_message(); + } + + pub fn file_start(&mut self, name: &str, size: i64) { + self.current_file_size = size.max(0) as u64; + self.bar.set_message(format!( + "[{}/{}] {}", + (self.files_done + 1).min(self.total_files.max(1)), + self.total_files.max(1), + truncate(name, 48), + )); + } + + pub fn file_progress(&mut self, _name: &str, written: i64, _size: i64) { + let position = self.completed_bytes.saturating_add(written.max(0) as u64); + self.bar.set_position(position.min(self.total_bytes)); + } + + pub fn file_done(&mut self, _name: &str) { + self.completed_bytes = self.completed_bytes.saturating_add(self.current_file_size); + self.files_done += 1; + self.bar + .set_position(self.completed_bytes.min(self.total_bytes)); + self.set_files_message(); + } + + pub fn message(&mut self, msg: &str) { + self.bar.set_message(truncate(msg, 48)); + } + + pub fn close(&mut self) { + self.bar.set_position(self.total_bytes); + self.bar.finish_and_clear(); + } + + fn set_files_message(&self) { + self.bar + .set_message(format!("{}/{} files", self.files_done, self.total_files)); + } +} + +fn bar_style() -> ProgressStyle { + ProgressStyle::with_template( + "{spinner:.green} {prefix} [{bar:32.cyan/blue}] {bytes}/{total_bytes} ({percent}%) {wide_msg}", + ) + .unwrap_or_else(|_| ProgressStyle::default_bar()) + .progress_chars("=> ") +} + +fn truncate(s: &str, max: usize) -> String { + if s.chars().count() <= max { + s.to_string() + } else { + let prefix: String = s.chars().take(max.saturating_sub(1)).collect(); + format!("{prefix}…") + } +} + fn mega(bytes: i64) -> f64 { bytes as f64 / 1e6 } @@ -184,4 +378,42 @@ mod tests { assert!(matches!(new(&logger, "text"), Reporter::Simple(_))); } + + #[test] + fn factory_enables_bars_only_for_interactive_text() { + assert!(!ProgressFactory::new("text", false, false).is_enabled()); + assert!(!ProgressFactory::new("text", true, true).is_enabled()); + assert!(!ProgressFactory::new("json", false, true).is_enabled()); + assert!(ProgressFactory::new("text", false, true).is_enabled()); + } + + #[test] + fn factory_reports_bars_per_server() { + let factory = ProgressFactory::new("text", false, true); + let (logger, _) = logger(false); + assert!(matches!( + factory.reporter(&logger, "server-a"), + Reporter::Bar(_) + )); + assert!(matches!( + factory.reporter(&logger, "server-b"), + Reporter::Bar(_) + )); + } + + #[test] + fn factory_falls_back_to_simple_when_disabled() { + let factory = ProgressFactory::new("text", false, false); + let (logger, _) = logger(false); + assert!(matches!( + factory.reporter(&logger, "server-a"), + Reporter::Simple(_) + )); + } + + #[test] + fn truncate_shortens_long_names() { + assert_eq!(truncate("short", 10), "short"); + assert_eq!(truncate("abcdefgh", 5), "abcd…"); + } }