snafu 0.9.2

An ergonomic error handling library
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

fn check<T: std::error::Error>() {}

mod inner {
    use snafu::prelude::*;

    #[derive(Debug, Snafu)]
    pub struct Error(InnerError);

    pub fn api() -> Result<i32, Error> {
        Ok(a()? + b()?)
    }

    pub fn not_positive(value: i32) -> Result<i32, Error> {
        ensure!(value < 1, TooBigSnafu { count: value });
        Ok(value)
    }

    pub fn boxed_inner(value: i32) -> Result<i32, Box<dyn std::error::Error>> {
        ensure!(value < 1, TooBigSnafu { count: value });
        Ok(value)
    }

    #[derive(Debug, Snafu)]
    enum InnerError {
        #[snafu(display("The value {count} is too big"))]
        TooBig { count: i32 },
    }

    fn a() -> Result<i32, InnerError> {
        TooBigSnafu { count: 1 }.fail()
    }

    fn b() -> Result<i32, InnerError> {
        TooBigSnafu { count: 2 }.fail()
    }
}

#[test]
fn implements_error() {
    check::<inner::Error>();
    let e = inner::api().unwrap_err();
    assert!(e.to_string().contains("too big"));
}

#[test]
fn ensure_opaque() {
    assert!(inner::not_positive(-1).is_ok());

    let e = inner::not_positive(2).unwrap_err();
    assert!(e.to_string().contains("too big"));
}

#[test]
fn ensure_boxed() {
    assert!(inner::boxed_inner(-1).is_ok());

    let e = inner::boxed_inner(2).unwrap_err();
    assert!(e.to_string().contains("too big"));
}

mod with_exact_source {
    use super::*;
    use snafu::prelude::*;

    #[derive(Debug, Snafu)]
    #[snafu(display("The inner error"))]
    struct InnerError;

    #[derive(Debug, Snafu)]
    struct MiddleError(InnerError);

    #[derive(Debug, Snafu)]
    #[snafu(source(from(exact)))]
    struct OuterError(MiddleError);

    trait LocalTrait {}
    impl LocalTrait for i32 {}

    impl<T> From<T> for OuterError
    where
        T: LocalTrait,
    {
        fn from(_: T) -> Self {
            OuterError(MiddleError(InnerError))
        }
    }

    #[test]
    fn usage() {
        check::<OuterError>();
        let e: OuterError = 42.into();
        assert_eq!(e.to_string(), "The inner error");
    }
}

mod with_generic_source {
    use super::*;
    use snafu::prelude::*;

    #[derive(Debug, Snafu)]
    #[snafu(display("The inner error"))]
    struct InnerError;

    #[derive(Debug, Snafu)]
    struct MiddleError(InnerError);

    #[derive(Debug, Snafu)]
    #[snafu(source(from(generic)))]
    struct OuterError(MiddleError);

    fn make_inner() -> Result<(), InnerError> {
        InnerSnafu.fail()
    }

    fn make_outer() -> Result<(), OuterError> {
        Ok(make_inner()?)
    }

    #[test]
    fn usage() {
        check::<OuterError>();
        let e: OuterError = make_outer().unwrap_err();
        assert_eq!(e.to_string(), "The inner error");
    }

    // This should basically be the same as the parent module, but
    // without the explicit `from(...)` attribute.
    mod is_default_behavior {
        use super::*;

        #[derive(Debug, Snafu)]
        #[snafu(display("The inner error"))]
        struct InnerError;

        #[derive(Debug, Snafu)]
        struct MiddleError(InnerError);

        #[derive(Debug, Snafu)]
        struct OuterError(MiddleError);

        fn make_inner() -> Result<(), InnerError> {
            InnerSnafu.fail()
        }

        fn make_outer() -> Result<(), OuterError> {
            Ok(make_inner()?)
        }

        #[test]
        fn usage() {
            check::<OuterError>();
            let e: OuterError = make_outer().unwrap_err();
            assert_eq!(e.to_string(), "The inner error");
        }
    }
}