uni_error 0.11.3

A simple, universal error type for Rust
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

use uni_error::cause::Cause;
use uni_error::convert::ErrorContext as _;
use uni_error::{SimpleError, UniError, UniKind};

use crate::common::{TestError, TestKind};

mod common;

#[test]
fn test_kind() {
    let error = UniError::from_kind(TestKind::NotATest);
    let kind = error.kind_ref();

    assert_eq!(kind.type_name(), "test_error::common::TestKind");
    assert_eq!(error.kind_value(), "NotATest");
    assert_eq!(error.kind_context_str(), Some("This is not a test!".into()));
    assert_eq!(error.kind_code(), 123);
}

#[test]
fn test_dyn_kind_error() {
    let err = UniError::from_kind(TestKind::NotATest);
    let error: UniError<dyn UniKind> = err.clone().into();

    assert_eq!(
        error.type_name(),
        "uni_error::error::UniError<test_error::common::TestKind>"
    );
    assert_eq!(error.kind_value(), "NotATest");
    assert_eq!(error.kind_context_str(), Some("This is not a test!".into()));
    assert_eq!(error.kind_code(), 123);

    match error.to_typed_kind::<TestKind>() {
        Some(err2) => assert_eq!(err2, err),
        None => panic!("Expected downcast to TestKind"),
    }
}

#[test]
fn test_dyn_kind_code() {
    let error = UniError::from_kind(TestKind::NotATest).into_dyn_kind_code();
    assert_eq!(error.kind_value(), "NotATest");
    assert_eq!(error.kind_context_str(), Some("This is not a test!".into()));
    assert_eq!(error.kind_code(), 123);
    assert_eq!(error.typed_code(), 123);

    let kind = error.kind_ref();
    match kind.downcast_ref::<TestKind>() {
        Some(kind) => assert_eq!(kind, &TestKind::NotATest),
        None => panic!("Expected downcast to TestKind"),
    }

    assert!(error.into_typed_kind::<TestKind>().is_some());
}

#[test]
fn test_dyn_kind_codes() {
    let error = UniError::from_kind(TestKind::NotATest).into_dyn_kind_codes();
    assert_eq!(error.kind_value(), "NotATest");
    assert_eq!(error.kind_context_str(), Some("This is not a test!".into()));
    assert_eq!(error.kind_code(), 123);
    assert_eq!(error.typed_code(), 123);
    assert_eq!(error.typed_code2(), 124);

    let kind = error.kind_ref();
    match kind.downcast_ref::<TestKind>() {
        Some(kind) => assert_eq!(kind, &TestKind::NotATest),
        None => panic!("Expected downcast to TestKind"),
    }

    assert!(error.into_typed::<TestKind>().is_some());
}

#[test]
fn test_root_cause() {
    let error = TestError::new("test".to_string(), None);
    let error: UniError<TestKind> = error.into();
    let error: UniError<dyn UniKind> = error.into();
    let root_cause = error.root_cause();

    assert!(matches!(root_cause, Some(Cause::UniStdError(_))));
    assert_eq!(
        root_cause.unwrap().type_name(),
        "test_error::common::TestError"
    );
}

#[test]
fn test_display() {
    let error = TestError::new("testing".to_string(), None);
    let error: UniError<TestKind> = error.kind_context(TestKind::NotATest, "is this a test?");

    assert_eq!(
        error.to_string(),
        "is this a test?: This is not a test!: TestError: testing"
    );
}

#[test]
fn test_simple_error_partial_eq() {
    let error1 = SimpleError::from_kind_default_context("test");
    let error2 = SimpleError::from_kind_default_context("test");
    let error3 = SimpleError::from_kind_default_context("test2");

    assert_eq!(error1, error2);
    assert_ne!(error1, error3);
}

#[test]
fn test_uni_error_partial_eq() {
    let error1 = UniError::from_kind_context(TestKind::Test, "test");
    let error2 = UniError::from_kind(TestKind::Test);
    let error3 = UniError::from_kind(TestKind::NotATest);

    assert_eq!(error1, error2);
    assert_ne!(error1, error3);
}