cargo-pretty-test 0.2.2

A console command to format cargo test output
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use crate::{
    parsing::{parse_cargo_test, Stats},
    prettify::{make_pretty, TestTree, ICON_NOTATION},
    regex::re,
};
use colored::Colorize;
use std::process::{Command, ExitCode, Output};
use termtree::Tree;

/// Output from `cargo test`
pub struct Emit {
    /// Raw output.
    output: Output,
    /// Don't parse the output. Forward the output instead.
    no_parse: bool,
}

impl Emit {
    pub fn run(self) -> ExitCode {
        let Emit { output, no_parse } = self;
        let stderr = strip_ansi_escapes::strip(output.stderr);
        let stdout = strip_ansi_escapes::strip(output.stdout);
        let stderr = String::from_utf8_lossy(&stderr);
        let stdout = String::from_utf8_lossy(&stdout);
        if no_parse {
            println!(
                "{phelp}\n{ICON_NOTATION}\n{sep}\n\n{help}",
                phelp = "cargo pretty-test help:".blue().bold(),
                sep = re().separator,
                help = "cargo test help:".blue().bold()
            );
            eprintln!("{stderr}");
            println!("{stdout}");
        } else {
            let (tree, stats) = parse_cargo_test_output(&stderr, &stdout);
            println!("{tree}");
            eprintln!("{stats}");
            if !stats.ok {
                return ExitCode::FAILURE;
            }
        }
        ExitCode::SUCCESS
    }
}

/// entrypoint for main.rs
pub fn run() -> ExitCode {
    cargo_test().run()
}

/// Collect arguments and forward them to `cargo test`.
///
/// Note: This filters some arguments that mess up the output, like
/// `--nocapture` which prints in the status part and hinders parsing.
pub fn cargo_test() -> Emit {
    let passin: Vec<_> = std::env::args().collect();
    let forward = if passin
        .get(..2)
        .is_some_and(|v| v[0].ends_with("cargo-pretty-test") && v[1] == "pretty-test")
    {
        // `cargo pretty-test` yields ["path-to-cargo-pretty-test", "pretty-test", rest]
        &passin[2..]
    } else {
        // `cargo-pretty-test` yields ["path-to-cargo-pretty-test", rest]
        &passin[1..]
    };
    let no_parse = passin.iter().any(|arg| arg == "--help" || arg == "-h");
    let args = forward.iter().filter(|arg| *arg != "--nocapture");
    Emit {
        output: Command::new("cargo")
            .arg("test")
            .args(args)
            .output()
            .expect("`cargo test` failed"),
        no_parse,
    }
}

pub fn parse_cargo_test_output<'s>(stderr: &'s str, stdout: &'s str) -> (TestTree<'s>, Stats) {
    let mut tree = Tree::new("Generated by cargo-pretty-test".bold().to_string().into());
    let mut stats = Stats::default();
    for (pkg, data) in parse_cargo_test(stderr, stdout).pkgs {
        stats += &data.stats;
        let root = data.stats.root_string(pkg.unwrap_or("tests")).into();
        tree.push(
            Tree::new(root).with_leaves(data.inner.into_iter().filter_map(|data| {
                let parsed = data.info.parsed;
                let detail_without_stats = parsed.detail;
                if !detail_without_stats.is_empty() {
                    eprintln!("{detail_without_stats}\n\n{}\n", re().separator);
                }
                let root = data.info.stats.subroot_string(data.runner.src.src_path);
                make_pretty(root, parsed.tree.into_iter())
            })),
        );
    }
    (tree, stats)
}