cargo-upkeep 0.1.7

Unified Rust project maintenance CLI (cargo subcommand)
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

use crate::core::error::Result;
use std::future::Future;

pub(super) async fn run_with_output<Output, Fut, J, P>(
    json: bool,
    runner: Fut,
    json_printer: J,
    text_printer: P,
) -> Result<()>
where
    Fut: Future<Output = Result<Output>>,
    J: FnOnce(&Output) -> Result<()>,
    P: FnOnce(&Output) -> Result<()>,
{
    let output = runner.await?;
    if json {
        json_printer(&output)
    } else {
        text_printer(&output)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::error::{ErrorCode, UpkeepError};
    use std::cell::Cell;

    #[derive(Debug)]
    #[allow(dead_code)] // Field used for test data construction
    struct TestOutput {
        value: i32,
    }

    fn sample_output() -> TestOutput {
        TestOutput { value: 42 }
    }

    #[tokio::test]
    async fn run_with_json_uses_json_printer() {
        let called_json = Cell::new(false);
        let called_text = Cell::new(false);

        run_with_output(
            true,
            async { Ok(sample_output()) },
            |_| {
                called_json.set(true);
                Ok(())
            },
            |_| {
                called_text.set(true);
                Ok(())
            },
        )
        .await
        .unwrap();

        assert!(called_json.get());
        assert!(!called_text.get());
    }

    #[tokio::test]
    async fn run_with_text_uses_text_printer() {
        let called_json = Cell::new(false);
        let called_text = Cell::new(false);

        run_with_output(
            false,
            async { Ok(sample_output()) },
            |_| {
                called_json.set(true);
                Ok(())
            },
            |_| {
                called_text.set(true);
                Ok(())
            },
        )
        .await
        .unwrap();

        assert!(!called_json.get());
        assert!(called_text.get());
    }

    #[tokio::test]
    async fn run_with_propagates_runner_error() {
        let err = run_with_output(
            true,
            async {
                Err(UpkeepError::message(
                    ErrorCode::InvalidData,
                    "runner failed",
                ))
            },
            |_: &TestOutput| Ok(()),
            |_: &TestOutput| Ok(()),
        )
        .await
        .unwrap_err();

        assert_eq!(err.code(), ErrorCode::InvalidData);
    }

    #[tokio::test]
    async fn run_with_propagates_json_printer_error() {
        let err = run_with_output(
            true,
            async { Ok(sample_output()) },
            |_| Err(UpkeepError::message(ErrorCode::Io, "json write failed")),
            |_| Ok(()),
        )
        .await
        .unwrap_err();

        assert_eq!(err.code(), ErrorCode::Io);
        assert!(err.to_string().contains("json write failed"));
    }

    #[tokio::test]
    async fn run_with_propagates_text_printer_error() {
        let err = run_with_output(
            false,
            async { Ok(sample_output()) },
            |_| Ok(()),
            |_| Err(UpkeepError::message(ErrorCode::Io, "text write failed")),
        )
        .await
        .unwrap_err();

        assert_eq!(err.code(), ErrorCode::Io);
        assert!(err.to_string().contains("text write failed"));
    }
}