pistonite-cu 0.9.2

Battery-included common utils to speed up development of rust tools
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

use pistonite_cu as cu;

#[test]
fn test_example1() {
    let msg = format!("{:?}", example1(42).unwrap_err());
    assert_eq!(
        msg,
        r"failed with arg 42

Caused by:
    example1"
    )
}

#[cu::context("failed with arg {arg}")]
fn example1(arg: u32) -> cu::Result<()> {
    cu::bail!("example1")
}

#[test]
fn test_example2() {
    let msg = format!("{:?}", example2("hello".to_string()).unwrap_err());
    assert_eq!(
        msg,
        r"failed with arg hello

Caused by:
    example2: hello"
    )
}

// 'pre' is needed because s is moved into the function
// so the error message needs to be formatted before running the function
#[cu::context(pre, format("failed with arg {s}"))]
fn example2(s: String) -> cu::Result<()> {
    cu::bail!("example2: {s}")
}

#[tokio::test]
async fn test_example3_err() {
    let msg = format!("{:?}", example3(4).await.unwrap_err());
    assert_eq!(
        msg,
        r"async failed with arg 4

Caused by:
    condition failed: `value > 4`"
    )
}

#[tokio::test]
async fn test_example3_ok() {
    assert!(example3(42).await.is_ok())
}

// question mark works as expected (context is added at return time)
#[cu::context("async failed with arg {}", s)]
async fn example3(s: u32) -> cu::Result<()> {
    let value = returns_ok(s)?;
    cu::ensure!(value > 4)?;
    Ok(())
}

#[tokio::test]
async fn test_example4_err() {
    let msg = format!("{:?}", example4("".to_string()).await.unwrap_err());
    assert_eq!(
        msg,
        r"async failed with arg 

Caused by:
    condition failed: `!value.is_empty()`"
    )
}

#[tokio::test]
async fn test_example4_ok() {
    assert!(example4("hello".to_string()).await.is_ok())
}

// question mark works as expected (context is added at return time)
#[cu::context(pre, format("async failed with arg {s}"))]
async fn example4(s: String) -> cu::Result<()> {
    let value = returns_ok(s)?;
    cu::ensure!(!value.is_empty())?;
    Ok(())
}

#[test]
fn test_example5() {
    let msg = format!("{:?}", Foo(7).example5().unwrap_err());
    assert_eq!(
        msg,
        r"Foo failed with arg 7

Caused by:
    example5"
    )
}

// associated functions also work
struct Foo(u32);
impl Foo {
    #[cu::context("Foo failed with arg {}", self.0)]
    fn example5(&self) -> cu::Result<()> {
        cu::bail!("example5")
    }
}

fn returns_ok<T>(t: T) -> cu::Result<T> {
    Ok(t)
}