pubnub 0.7.0

PubNub SDK for Rust
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

//! Publish result module.
//!
//! This module contains the `PublishResult` type.
//! The `PublishResult` type is used to represent the result of a publish operation.

use crate::{
    core::{service_response::APIErrorBody, PubNubError},
    lib::alloc::string::String,
};

/// The result of a publish operation.
/// It contains the timetoken of the published message.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PublishResult {
    /// The timetoken of the published message.
    pub timetoken: String,
}

/// The response body of a publish operation.
/// It can be either a tuple with data from the Publish service
/// or an [`OtherResponse`] from other services.
///
/// It's used for deserialization of the publish response. This type is an
/// intermediate type between the raw response body and the [`PublishResult`]
/// type.
///
/// [`OtherResponse`]: struct.OtherResponse.html
/// [`PublishResult`]: struct.PublishResult.html
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(untagged))]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PublishResponseBody {
    /// The response body of a publish operation in publish service.
    /// It contains the error indicator, the message from service and the
    /// timetoken in this order.
    ///
    /// The error indicator is `1` if the operation was successful and `0`
    /// otherwise.
    ///
    /// # Example
    /// ```json
    /// [1, "Sent", "15815800000000000"]
    /// ```
    SuccessResponse(i32, String, String),
    /// The response body of a publish operation in other services.
    ErrorResponse(APIErrorBody),
}

impl TryFrom<PublishResponseBody> for PublishResult {
    type Error = PubNubError;

    fn try_from(value: PublishResponseBody) -> Result<Self, Self::Error> {
        match value {
            PublishResponseBody::SuccessResponse(error_indicator, message, timetoken) => {
                if error_indicator == 1 {
                    Ok(PublishResult { timetoken })
                } else {
                    Err(PubNubError::general_api_error(message, None, None))
                }
            }
            PublishResponseBody::ErrorResponse(resp) => Err(resp.into()),
        }
    }
}

#[cfg(test)]
mod should {
    use super::*;
    use crate::core::TransportResponse;

    fn body_to_result(
        body: PublishResponseBody,
        response: TransportResponse,
    ) -> Result<PublishResult, PubNubError> {
        match body {
            PublishResponseBody::SuccessResponse(error_indicator, message, timetoken) => {
                if error_indicator == 1 {
                    Ok(PublishResult { timetoken })
                } else {
                    Err(PubNubError::general_api_error(
                        message,
                        Some(response.status),
                        Some(Box::new(response)),
                    ))
                }
            }
            PublishResponseBody::ErrorResponse(resp) => {
                let error: PubNubError = resp.into();
                Err(error.attach_response(response))
            }
        }
    }

    #[test]
    fn parse_publish_response() {
        let body =
            PublishResponseBody::SuccessResponse(1, "Sent".into(), "15815800000000000".into());
        let result = body_to_result(
            body,
            TransportResponse {
                status: 200,
                ..Default::default()
            },
        )
        .unwrap();

        assert_eq!(result.timetoken, "15815800000000000");
    }

    #[test]
    fn parse_other_response() {
        let status = 400;
        let body = PublishResponseBody::ErrorResponse(APIErrorBody::AsObjectWithService {
            status,
            error: true,
            service: "service".into(),
            message: "error".into(),
        });
        let result = body_to_result(
            body,
            TransportResponse {
                status,
                ..Default::default()
            },
        );

        assert!(result.is_err());
    }
}