Skip to main content

ctrader_connector/open_api/
errors.rs

1//! Conversions from the error messages of the Open API to the shared error types.
2
3use crate::common::errors::{ErrorCode, ServerError};
4use crate::common::ids::AccountId;
5use crate::open_api::messages::{ProtoErrorCode, ProtoErrorRes, ProtoOaErrorCode, ProtoOaErrorRes};
6
7impl From<ProtoErrorCode> for ErrorCode {
8    fn from(code: ProtoErrorCode) -> Self {
9        Self::from_wire(code.as_str_name())
10    }
11}
12
13impl From<ProtoOaErrorCode> for ErrorCode {
14    fn from(code: ProtoOaErrorCode) -> Self {
15        Self::from_wire(code.as_str_name())
16    }
17}
18
19impl From<ProtoErrorRes> for ServerError {
20    fn from(response: ProtoErrorRes) -> Self {
21        let mut error = Self::new(ErrorCode::from_wire(&response.error_code));
22        error.description = response.description;
23        error.maintenance_end_timestamp = response
24            .maintenance_end_timestamp
25            .and_then(|timestamp| i64::try_from(timestamp).ok());
26        error
27    }
28}
29
30impl From<ProtoOaErrorRes> for ServerError {
31    fn from(response: ProtoOaErrorRes) -> Self {
32        let mut error = Self::new(ErrorCode::from_wire(&response.error_code));
33        error.description = response.description;
34        error.account_id = response
35            .ctid_trader_account_id
36            .and_then(|id| AccountId::new(id).ok());
37        error.maintenance_end_timestamp = response.maintenance_end_timestamp;
38        error
39    }
40}
41
42#[cfg(test)]
43mod tests {
44    use crate::common::errors::{ErrorCode, ServerError};
45    use crate::common::ids::AccountId;
46    use crate::open_api::messages::{
47        ProtoErrorCode, ProtoErrorRes, ProtoOaErrorCode, ProtoOaErrorRes,
48    };
49
50    #[test]
51    fn every_common_code_maps_to_a_variant() {
52        let codes: Vec<_> = (0..=1000)
53            .filter_map(|number| ProtoErrorCode::try_from(number).ok())
54            .collect();
55        assert_eq!(codes.len(), 10);
56        for code in codes {
57            let mapped = ErrorCode::from(code);
58            assert!(mapped.is_known(), "{code:?}");
59            assert_eq!(mapped.as_str(), code.as_str_name());
60        }
61        assert_eq!(
62            ErrorCode::from(ProtoErrorCode::MarketClosed),
63            ErrorCode::MarketClosed
64        );
65    }
66
67    #[test]
68    fn every_open_api_code_maps_to_a_variant() {
69        let codes: Vec<_> = (0..=1000)
70            .filter_map(|number| ProtoOaErrorCode::try_from(number).ok())
71            .collect();
72        assert_eq!(codes.len(), 43);
73        for code in codes {
74            let mapped = ErrorCode::from(code);
75            assert!(mapped.is_known(), "{code:?}");
76            assert_eq!(mapped.as_str(), code.as_str_name());
77        }
78        assert_eq!(
79            ErrorCode::from(ProtoOaErrorCode::ChAccessTokenInvalid),
80            ErrorCode::ChAccessTokenInvalid
81        );
82    }
83
84    #[test]
85    fn common_error_response_keeps_code_and_detail() {
86        let error = ServerError::from(ProtoErrorRes {
87            payload_type: None,
88            error_code: "FRAME_TOO_LONG".to_owned(),
89            description: Some("frame of 70000 bytes".to_owned()),
90            maintenance_end_timestamp: Some(1_700_000_000_000),
91        });
92        assert_eq!(error.code, ErrorCode::FrameTooLong);
93        assert_eq!(error.description.as_deref(), Some("frame of 70000 bytes"));
94        assert_eq!(error.maintenance_end_timestamp, Some(1_700_000_000_000));
95        let overflowing = ServerError::from(ProtoErrorRes {
96            payload_type: None,
97            error_code: "UNKNOWN_ERROR".to_owned(),
98            description: None,
99            maintenance_end_timestamp: Some(u64::MAX),
100        });
101        assert_eq!(overflowing.maintenance_end_timestamp, None);
102    }
103
104    #[test]
105    fn open_api_error_response_keeps_code_and_detail() {
106        let error = ServerError::from(ProtoOaErrorRes {
107            payload_type: None,
108            ctid_trader_account_id: Some(7),
109            error_code: "SERVER_IS_UNDER_MAINTENANCE".to_owned(),
110            description: Some("back soon".to_owned()),
111            maintenance_end_timestamp: Some(1_700_000_000_000),
112        });
113        assert_eq!(error.code, ErrorCode::ServerIsUnderMaintenance);
114        assert_eq!(error.account_id.map(AccountId::get), Some(7));
115        assert_eq!(error.description.as_deref(), Some("back soon"));
116        assert_eq!(error.maintenance_end_timestamp, Some(1_700_000_000_000));
117    }
118
119    #[test]
120    fn unknown_code_in_a_response_is_kept_as_text() {
121        let error = ServerError::from(ProtoOaErrorRes {
122            payload_type: None,
123            ctid_trader_account_id: None,
124            error_code: "BRAND_NEW_CODE".to_owned(),
125            description: None,
126            maintenance_end_timestamp: None,
127        });
128        assert_eq!(error.code, ErrorCode::Unknown("BRAND_NEW_CODE".to_owned()));
129        assert_eq!(error.account_id, None);
130        assert_eq!(error.to_string(), "server error BRAND_NEW_CODE");
131    }
132}