integra8_tree_formatter 0.0.5-rc1

Tree structured output formatters for displaying test results for the Integra8 test framework. 
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use std::io::Write;

use integra8::formatters::models::report::ComponentRunReport;
use integra8::formatters::models::ComponentResult;

use crate::parameters::DetailLevel;
use crate::styles::TreeStyle;
use crate::writer::{Prefix, PrefixedTextWriter};

#[derive(Clone, Debug)]
pub struct ResultsNode<'a> {
    pub report: &'a ComponentRunReport,
    pub children: Vec<ResultsNode<'a>>,
}

impl<'a> ResultsNode<'a> {
    pub fn from_report(report: &'a ComponentRunReport) -> Self {
        Self {
            report: report,
            children: Vec::new(),
        }
    }

    pub fn children(&self, detail_level: &DetailLevel) -> Vec<&ResultsNode<'a>> {
        match detail_level {
            // In Error or Warn detail level, remove
            // all the non error and warning nodes.
            // * Note:
            //      we have to include warn nodes even
            //      when in error detail level, as the
            //      Error nodes has have warning nodes has parents
            DetailLevel::Error | DetailLevel::Warning => self
                .children
                .iter()
                .filter(|c| c.report.result.has_failed() || c.report.result.has_warn())
                .collect(),
            _ => self.children.iter().collect(),
        }
    }

    pub fn add_child_node(&mut self, child: ResultsNode<'a>) {
        self.children.push(child)
    }

    pub fn render_node<W: Write>(
        &self,
        output_formatter: &mut PrefixedTextWriter<W>,
        style: &TreeStyle,
        detail_level: &DetailLevel,
    ) -> std::io::Result<()> {
        crate::render::render_component_heading(
            output_formatter,
            &self.report,
            style,
            detail_level,
        )?;

        let render_attributes = match &self.report.result {
            ComponentResult::Fail(_) => true,
            ComponentResult::Warning(_) => {
                detail_level != &DetailLevel::Error && detail_level != &DetailLevel::StopWatch
            }
            ComponentResult::Pass(_) => detail_level == &DetailLevel::Verbose,
            ComponentResult::DidNotRun(_) => false,
        };

        if render_attributes {
            crate::render::render_node_attributes(
                output_formatter,
                &self.report,
                style,
                detail_level,
            )?;
        }
        Ok(())
    }
}

pub struct ResultsTree<'a> {
    root: ResultsNode<'a>,
}

impl<'a> ResultsTree<'a> {
    pub fn new(root: ResultsNode<'a>) -> Self {
        Self { root }
    }

    pub fn render_tree<W: Write>(
        &self,
        writer: W,
        style: &TreeStyle,
        detail_level: &DetailLevel,
    ) -> std::io::Result<()> {
        let mut prefixed_text_writer = PrefixedTextWriter::new(writer);
        // Ensure we are on a new line, in when running in non child process mode
        // its possible there is ran text logged on the current line
        prefixed_text_writer.write_newline()?;
        self.render_node_branches(&mut prefixed_text_writer, style, &self.root, detail_level)
    }

    pub fn render_node_branches<W: Write>(
        &self,
        prefixed_writer: &mut PrefixedTextWriter<W>,
        style: &TreeStyle,
        node: &ResultsNode,
        detail_level: &DetailLevel,
    ) -> std::io::Result<()> {
        self.render_node(prefixed_writer, style, node, detail_level)?;

        if let Some((last_child, children)) = node.children(detail_level).split_last() {
            for child in children {
                self.render_branch(prefixed_writer, style, child, detail_level)?;
            }
            self.render_last_branch(prefixed_writer, style, last_child, detail_level)?;
        }

        Ok(())
    }

    fn render_branch<W: Write>(
        &self,
        prefixed_writer: &mut PrefixedTextWriter<W>,
        style: &TreeStyle,
        node: &ResultsNode,
        detail_level: &DetailLevel,
    ) -> std::io::Result<()> {
        prefixed_writer.push(Prefix::with(&style.branch.child).then_next(&style.branch.no_child));
        let res = self.render_node_branches(prefixed_writer, style, node, detail_level);
        prefixed_writer.pop();
        res
    }

    fn render_last_branch<W: Write>(
        &self,
        prefixed_writer: &mut PrefixedTextWriter<W>,
        style: &TreeStyle,
        node: &ResultsNode,
        detail_level: &DetailLevel,
    ) -> std::io::Result<()> {
        prefixed_writer
            .push(Prefix::with(&style.branch.last_child).then_next(&style.branch.no_branch));
        let res = self.render_node_branches(prefixed_writer, style, node, detail_level);
        prefixed_writer.pop();
        res
    }

    fn render_node<W: Write>(
        &self,
        prefixed_writer: &mut PrefixedTextWriter<W>,
        style: &TreeStyle,
        node: &ResultsNode,
        detail_level: &DetailLevel,
    ) -> std::io::Result<()> {
        // Nodes can print multiple lines of attributes,
        // so the "next" line correct indentation is is determined
        // by if the current node has any children.
        prefixed_writer.push(match node.children.is_empty() {
            true => Prefix::next_with(&style.branch.no_branch),
            false => Prefix::next_with(&style.branch.no_child),
        });

        let res = node.render_node(prefixed_writer, style, detail_level);
        prefixed_writer.pop();
        res
    }
}