pipedash-core 0.4.0

Framework-agnostic core library for Pipedash
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

use serde::{
    Deserialize,
    Serialize,
};

use super::error::FailureKind;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RefreshState {
    Ok,
    Failed,
    Pending,
    Recent,
    NotFound,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RefreshResult {
    pub provider_id: i64,
    pub state: RefreshState,
    pub kind: Option<FailureKind>,
    pub message: Option<String>,
}

impl RefreshResult {
    pub fn new(provider_id: i64, state: RefreshState) -> Self {
        Self {
            provider_id,
            state,
            kind: None,
            message: None,
        }
    }

    pub fn failed(provider_id: i64, kind: FailureKind, message: String) -> Self {
        Self {
            provider_id,
            state: RefreshState::Failed,
            kind: Some(kind),
            message: Some(message),
        }
    }
}

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

    #[test]
    fn serializes_to_the_wire_contract() {
        let result = RefreshResult::failed(7, FailureKind::RateLimited, "slow down".to_string());

        assert_eq!(
            serde_json::to_value(&result).unwrap(),
            serde_json::json!({
                "provider_id": 7,
                "state": "failed",
                "kind": "rate_limited",
                "message": "slow down"
            })
        );
        assert_eq!(
            serde_json::to_value(RefreshResult::new(1, RefreshState::NotFound)).unwrap(),
            serde_json::json!({
                "provider_id": 1,
                "state": "not_found",
                "kind": null,
                "message": null
            })
        );
    }
}