zulip-api 0.0.8

Client library for interacting with the Zulip 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

use serde::{Deserialize, Serialize};
use zeroize::Zeroize;

use super::{ApiResult, ErrorCode};
use crate::{impl_default, impl_display, impl_response};

/// Represents the base response from a Zulip API server.
#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize, Zeroize)]
pub struct BaseResponse {
    msg: String,
    result: ApiResult,
    #[serde(skip_serializing_if = "Option::is_none")]
    code: Option<ErrorCode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    ignored_parameters_unsupported: Option<Vec<String>>,
}

impl BaseResponse {
    /// Creates a new [Self].
    pub const fn new() -> Self {
        Self {
            msg: String::new(),
            result: ApiResult::new(),
            code: None,
            ignored_parameters_unsupported: None,
        }
    }
}

impl_response!(BaseResponse);

impl_default!(BaseResponse);
impl_display!(BaseResponse);

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

    #[test]
    fn test_success_response() {
        let msg = "test response";
        let msg_json = serde_json::to_string(&msg).unwrap();

        let result = ApiResult::Success;
        let result_json = serde_json::to_string(&result).unwrap();

        let response = BaseResponse::new().with_msg(msg).with_result(result);
        let response_json = format!(r#"{{"msg":{msg_json},"result":{result_json}}}"#);

        assert_eq!(serde_json::to_string(&response).unwrap(), response_json);
        assert_eq!(
            serde_json::from_str::<BaseResponse>(&response_json).unwrap(),
            response
        );

        assert_eq!(response.msg(), msg);
        assert_eq!(response.result(), result);
        assert_eq!(response.code(), None);
    }

    #[test]
    fn test_error_response() {
        let msg = "test response";
        let msg_json = serde_json::to_string(&msg).unwrap();

        let result = ApiResult::Error;
        let result_json = serde_json::to_string(&result).unwrap();

        let code = ErrorCode::BadRequest;
        let code_json = serde_json::to_string(&code).unwrap();

        let response = BaseResponse::new()
            .with_msg(msg)
            .with_result(result)
            .with_code(code);
        let response_json =
            format!(r#"{{"msg":{msg_json},"result":{result_json},"code":{code_json}}}"#);

        assert_eq!(serde_json::to_string(&response).unwrap(), response_json);
        assert_eq!(
            serde_json::from_str::<BaseResponse>(&response_json).unwrap(),
            response
        );

        assert_eq!(response.msg(), msg);
        assert_eq!(response.result(), result);
        assert_eq!(response.code(), Some(code));
    }
}