scrut 0.4.3

A simple and powerful test framework for CLI applications
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
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

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

use std::collections::HashMap;

use serde::Serialize;
use serde::ser::SerializeMap;

use crate::escaping::Escaper;
use crate::output::Output;
use crate::parsers::parser::ParserType;
use crate::testcase::Result as TestCaseResult;
use crate::testcase::TestCase;

/// Aggregation of all that a renderer could possibly need to build a readable,
/// understandable output
pub struct Outcome {
    /// The path / URL of the test
    pub location: Option<String>,

    /// The output that this outcome describes
    pub output: Output,

    /// The testcase that this outcome is about
    pub testcase: TestCase,

    /// The original format the testcase was written in
    pub format: ParserType,

    // The output escaping mode this outcome needs to have
    pub escaping: Escaper,

    /// The result of validating the [`crate::testcase::TestCase`]
    pub result: TestCaseResult<()>,
}

impl Serialize for Outcome {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let mut count = 2;
        if self.location.is_some() {
            count += 1;
        }
        if self.result.is_err() {
            count += 1;
        }
        let mut outcome = serializer.serialize_map(Some(count))?;
        if let Some(ref location) = self.location {
            outcome.serialize_entry("location", location)?;
        }
        match &self.result {
            Err(err) => {
                outcome.serialize_entry("output", &self.output)?;
                outcome.serialize_entry("testcase", &self.testcase)?;
                outcome.serialize_entry("result", err)?;
            }
            Ok(_) => {
                outcome.serialize_entry("title", &self.testcase.title)?;
                let mut map = HashMap::new();
                map.insert("kind", "success");
                outcome.serialize_entry("result", &map)?;
            }
        }
        outcome.end()
    }
}

#[cfg(test)]
mod tests {
    use super::Outcome;
    use crate::escaping::Escaper;
    use crate::parsers::parser::ParserType;
    use crate::testcase::TestCaseError;

    #[test]
    fn test_serialize() {
        use crate::test_expectation;
        use crate::testcase::TestCase;

        let outcomes = vec![
            (
                "error",
                Outcome {
                    location: Some("path/file.md".to_string()),
                    output: ("stdout", "stderr", Some(123)).into(),
                    testcase: TestCase {
                        title: "the title".to_string(),
                        shell_expression: "the command".to_string(),
                        expectations: vec![test_expectation!("equal", "foo")],
                        exit_code: Some(234),
                        line_number: 234,
                        ..Default::default()
                    },
                    result: Err(TestCaseError::InvalidExitCode {
                        actual: 123,
                        expected: 234,
                    }),
                    escaping: Escaper::default(),
                    format: ParserType::Markdown,
                },
            ),
            (
                "success",
                Outcome {
                    location: Some("path/file.md".to_string()),
                    output: ("stdout", "stderr", Some(123)).into(),
                    testcase: TestCase {
                        title: "the title".to_string(),
                        shell_expression: "the command".to_string(),
                        expectations: vec![test_expectation!("equal", "foo")],
                        exit_code: Some(123),
                        line_number: 234,
                        ..Default::default()
                    },
                    result: Ok(()),
                    escaping: Escaper::default(),
                    format: ParserType::Markdown,
                },
            ),
        ];

        for (name, outcome) in outcomes {
            insta::assert_json_snapshot!(name, outcome);
        }
    }
}