infinite-errors 0.2.1

Generic error handling framework with static backtraces
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

use assert_matches::assert_matches;
use derive_more::{Display, From};

use infinite_errors::{declare_error_type, err_context};

const BASE_ERROR_MESSAGE: &str = "test";

#[derive(Debug, Display, From)]
pub enum TestErrorKind {
    Context,
    BaseError(&'static str),
}

declare_error_type!(TestErrorKind);

type TestResult = Result<(), Error>;

#[test]
fn err_context_ok() {
    let res: TestResult = TestResult::Ok(()).err_context(TestErrorKind::Context);
    res.unwrap();
}

#[test]
fn err_context_err() {
    let err: Error = TestResult::Err(Error::from(TestErrorKind::BaseError("test")))
        .err_context(TestErrorKind::Context)
        .unwrap_err();

    assert_matches!(err.kind(), TestErrorKind::Context);
    assert_matches!(
        err.cause().unwrap().kind(),
        TestErrorKind::BaseError("test")
    );
    assert_matches!(err.cause().unwrap().cause(), None);
}

#[test]
fn err_context_with_err() {
    let err: Error = TestResult::Err(Error::from(TestErrorKind::BaseError("test")))
        .err_context_with(|| TestErrorKind::Context)
        .unwrap_err();

    assert_matches!(err.kind(), TestErrorKind::Context);
    assert_matches!(
        err.cause().unwrap().kind(),
        TestErrorKind::BaseError("test")
    );
    assert_matches!(err.cause().unwrap().cause(), None);
}

#[test]
fn err_context_macro_fn() {
    #[err_context(TestErrorKind::Context)]
    fn test() -> TestResult {
        Err(TestErrorKind::BaseError(BASE_ERROR_MESSAGE))
    }

    assert_correct_error_context(test());
}

#[test]
fn err_context_macro_fn_try_return() {
    #[err_context(TestErrorKind::Context)]
    fn test() -> TestResult {
        Err(TestErrorKind::BaseError(BASE_ERROR_MESSAGE))?;

        TestResult::Ok(())
    }

    assert_correct_error_context(test());
}

#[test]
fn err_context_macro_async_fn() {
    #[err_context(TestErrorKind::Context)]
    async fn test() -> TestResult {
        Err(TestErrorKind::BaseError(BASE_ERROR_MESSAGE))
    }

    assert_correct_error_context(futures_executor::block_on(test()));
}

#[test]
fn err_context_macro_async_fn_try_return() {
    #[err_context(TestErrorKind::Context)]
    async fn test() -> TestResult {
        Err(TestErrorKind::BaseError(BASE_ERROR_MESSAGE))?;

        TestResult::Ok(())
    }

    assert_correct_error_context(futures_executor::block_on(test()));
}

fn assert_correct_error_context(res: TestResult) {
    let err = res.unwrap_err();

    assert_matches!(err.kind(), TestErrorKind::Context);
    assert_matches!(
        err.cause().unwrap().kind(),
        TestErrorKind::BaseError(BASE_ERROR_MESSAGE)
    );
    assert_matches!(err.cause().unwrap().cause(), None);
}