bitaxe_api 0.5.1

Crate for interacting with the Bitaxe API.
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum StringOrInt {
    String(String),
    Int(i64),
}

impl StringOrInt {
    pub fn as_str(&self) -> Option<&str> {
        match self {
            StringOrInt::String(s) => Some(s),
            StringOrInt::Int(_) => None,
        }
    }

    pub fn as_int(&self) -> Option<i64> {
        match self {
            StringOrInt::String(_) => None,
            StringOrInt::Int(i) => Some(*i),
        }
    }

    pub fn into_string(self) -> String {
        match self {
            StringOrInt::String(s) => s,
            StringOrInt::Int(i) => i.to_string(),
        }
    }

    pub fn into_i64(self) -> Option<i64> {
        match self {
            StringOrInt::String(s) => s.parse().ok(),
            StringOrInt::Int(i) => Some(i),
        }
    }
}

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

    #[test]
    fn test_deserialize_from_string() {
        let json = r#""hello""#;
        let result: StringOrInt = serde_json::from_str(json).unwrap();
        assert!(matches!(result, StringOrInt::String(_)));
        assert_eq!(result.as_str(), Some("hello"));
    }

    #[test]
    fn test_deserialize_from_int() {
        let json = r#"42"#;
        let result: StringOrInt = serde_json::from_str(json).unwrap();
        assert!(matches!(result, StringOrInt::Int(_)));
        assert_eq!(result.as_int(), Some(42));
    }

    #[test]
    fn test_serialize_string() {
        let value = StringOrInt::String("test".to_string());
        let json = serde_json::to_string(&value).unwrap();
        assert_eq!(json, "\"test\"");
    }

    #[test]
    fn test_serialize_int() {
        let value = StringOrInt::Int(123);
        let json = serde_json::to_string(&value).unwrap();
        assert_eq!(json, "123");
    }

    #[test]
    fn test_into_string() {
        let s = StringOrInt::String("world".to_string()).into_string();
        assert_eq!(s, "world");

        let i = StringOrInt::Int(456).into_string();
        assert_eq!(i, "456");
    }

    #[test]
    fn test_into_i64() {
        let s = StringOrInt::String("789".to_string()).into_i64();
        assert_eq!(s, Some(789));

        let i = StringOrInt::Int(999).into_i64();
        assert_eq!(i, Some(999));

        let invalid = StringOrInt::String("not_a_number".to_string()).into_i64();
        assert_eq!(invalid, None);
    }
}