eventuary-core 0.1.0

Core event model and async IO traits for eventuary
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

use thiserror::Error;

#[derive(Error, Debug, Clone)]
pub enum Error {
    #[error("invalid topic: {0}")]
    InvalidTopic(String),

    #[error("invalid namespace: {0}")]
    InvalidNamespace(String),

    #[error("invalid organization: {0}")]
    InvalidOrganization(String),

    #[error("invalid metadata key: {0}")]
    InvalidMetadataKey(String),

    #[error("invalid payload: {0}")]
    InvalidPayload(String),

    #[error("invalid event key: {0}")]
    InvalidEventKey(String),

    #[error("invalid consumer group id: {0}")]
    InvalidConsumerGroupId(String),

    #[error("invalid owner id: {0}")]
    InvalidOwnerId(String),

    #[error("ownership lost: {0}")]
    OwnershipLost(String),

    #[error("invalid start position: {0}")]
    InvalidStartFrom(String),

    #[error("invalid cursor: {0}")]
    InvalidCursor(String),

    #[error("serialization error: {0}")]
    Serialization(String),

    #[error("store error: {0}")]
    Store(String),

    #[error("handler error: {0}")]
    Handler(String),

    #[error("timeout: {0}")]
    Timeout(String),

    #[error("config error: {0}")]
    Config(String),
}

pub type Result<T> = std::result::Result<T, Error>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn config_variant_is_constructible() {
        let err = Error::Config("missing url".to_owned());
        assert!(matches!(err, Error::Config(_)));
        assert_eq!(err.to_string(), "config error: missing url");
    }

    #[test]
    fn invalid_cursor_variant_is_constructible() {
        let err = Error::InvalidCursor("partition count changed".to_owned());
        assert!(matches!(err, Error::InvalidCursor(_)));
        assert_eq!(err.to_string(), "invalid cursor: partition count changed");
    }

    #[test]
    fn error_is_cloneable() {
        let err = Error::Store("write failed".to_owned());
        let cloned = err.clone();

        assert_eq!(err.to_string(), cloned.to_string());
    }
}