nestum 0.3.2

Proc-macro for nested enum paths like Enum1::Variant1::VariantA
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

use nestum::{nested, nestum};
use serde::{Deserialize, Serialize};
use std::{error::Error as _, io};
use thiserror::Error;

#[nestum]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum DocumentEvent {
    Created { id: u64 },
    Renamed { title: String },
}

#[nestum]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum Event {
    Document(DocumentEvent),
    Health,
}

#[nestum]
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum DocumentError {
    #[error("document not found")]
    NotFound,
    #[error("invalid title: {0}")]
    InvalidTitle(String),
}

#[nestum]
#[derive(Debug, Error)]
pub enum ApiError {
    #[error(transparent)]
    Document(#[from] DocumentError),
    #[error("transport error")]
    Transport,
}

#[nestum]
#[derive(Debug, Error)]
pub enum LeafError {
    #[error(transparent)]
    Io(#[from] io::Error),
}

#[nestum]
#[derive(Debug, Error)]
pub enum ServiceError {
    #[error(transparent)]
    Leaf(#[from] LeafError),
    #[error("storage failed at {path}")]
    Storage {
        path: &'static str,
        #[source]
        source: io::Error,
    },
}

#[nestum]
#[derive(Debug, Error)]
pub enum OuterError {
    #[error(transparent)]
    Service(#[from] ServiceError),
}

#[test]
fn serde_round_trip_preserves_nested_envelope_shape() {
    let event: Event::Enum = nested! {
        Event::Document::Renamed {
            title: "Spec".to_string(),
        }
    };

    let json = serde_json::to_value(&event).expect("event should serialize");
    assert_eq!(
        json,
        serde_json::json!({
            "Document": {
                "Renamed": {
                    "title": "Spec"
                }
            }
        })
    );

    let decoded: Event::Enum = serde_json::from_value(json).expect("event should deserialize");
    assert_eq!(decoded, event);

    let ok = nested! {
        matches!(decoded, Event::Document::Renamed { title } if title == "Spec")
    };
    assert!(ok);
}

#[test]
fn thiserror_transparent_and_from_work_with_nested_enums() {
    let err: ApiError::Enum = DocumentError::InvalidTitle("draft".to_string()).into();

    assert_eq!(err.to_string(), "invalid title: draft");

    let ok = nested! {
        matches!(err, ApiError::Document::InvalidTitle(title) if title == "draft")
    };
    assert!(ok);
}

#[test]
fn transitive_from_reaches_the_outer_error_envelope() {
    fn fail() -> Result<(), OuterError::Enum> {
        Err(io::Error::other("disk broke"))?;
        Ok(())
    }

    let err = fail().expect_err("io leaf error should convert into the outer envelope");
    assert_eq!(err.to_string(), "disk broke");

    let ok = nested! {
        matches!(err, OuterError::Service::Leaf::Io(source) if source.to_string() == "disk broke")
    };
    assert!(ok);
}

#[test]
fn named_field_nested_errors_keep_their_source_chain() {
    let err: OuterError::Enum = nested! {
        OuterError::Service::Storage {
            path: "todos.db",
            source: io::Error::other("disk broke"),
        }
    };

    assert_eq!(err.to_string(), "storage failed at todos.db");
    let source = err
        .source()
        .expect("named-field source should be preserved");
    assert_eq!(source.to_string(), "disk broke");
}