rusftx/rest/requests/
get_historical_index.rs

1use crate::rest::model::candle::Candle;
2use crate::rest::request::{AuthenticatedRequest, Request, UnauthenticatedRequest};
3use chrono::serde::ts_seconds_option;
4use chrono::{DateTime, Utc};
5use std::borrow::Cow;
6
7#[derive(Debug, builder_pattern::Builder)]
8pub struct GetHistoricalIndexRequest {
9    #[into]
10    pub market_name: String,
11    pub resolution: u32,
12    #[default(None)]
13    pub start_time: Option<DateTime<Utc>>,
14    #[default(None)]
15    pub end_time: Option<DateTime<Utc>>,
16}
17
18#[derive(Debug, serde::Serialize)]
19pub struct GetHistoricalIndexRequestQuery {
20    pub resolution: u32,
21    #[serde(with = "ts_seconds_option")]
22    pub start_time: Option<DateTime<Utc>>,
23    #[serde(with = "ts_seconds_option")]
24    pub end_time: Option<DateTime<Utc>>,
25}
26
27impl Request for GetHistoricalIndexRequest {
28    type Response = Vec<Candle>;
29    type Query = GetHistoricalIndexRequestQuery;
30    type Body = ();
31
32    fn path(&self) -> Cow<str> {
33        format!("indexes/{}/candles", self.market_name).into()
34    }
35
36    fn method(&self) -> http::Method {
37        http::Method::GET
38    }
39
40    fn query(&self) -> Option<Self::Query> {
41        Some(GetHistoricalIndexRequestQuery {
42            resolution: self.resolution,
43            start_time: self.start_time,
44            end_time: self.end_time,
45        })
46    }
47}
48
49impl AuthenticatedRequest for GetHistoricalIndexRequest {}
50impl UnauthenticatedRequest for GetHistoricalIndexRequest {}
51
52#[cfg(test)]
53mod tests {
54    use crate::rest::requests::get_historical_index::GetHistoricalIndexRequest;
55    use crate::rest::requests::test_utils;
56
57    #[tokio::test]
58    async fn test_get_historical_index() {
59        let rest_api = test_utils::get_rest_api_with_authentication_from_env();
60        let request = GetHistoricalIndexRequest::new()
61            .market_name("BTC-PERP")
62            .resolution(60)
63            .build();
64        let result = rest_api.send(request).await;
65        assert!(result.is_ok());
66    }
67
68    #[tokio::test]
69    async fn test_get_historical_index_with_start_time() {
70        let rest_api = test_utils::get_rest_api_with_authentication_from_env();
71        let request = GetHistoricalIndexRequest::new()
72            .market_name("BTC-PERP")
73            .resolution(60)
74            .start_time(Some(chrono::Utc::now() - chrono::Duration::days(1)))
75            .build();
76        let result = rest_api.send(request).await;
77        assert!(result.is_ok());
78    }
79
80    #[tokio::test]
81    async fn test_get_historical_index_with_end_time() {
82        let rest_api = test_utils::get_rest_api_with_authentication_from_env();
83        let request = GetHistoricalIndexRequest::new()
84            .market_name("BTC-PERP")
85            .resolution(60)
86            .end_time(Some(chrono::Utc::now() - chrono::Duration::days(1)))
87            .build();
88        let result = rest_api.send(request).await;
89        assert!(result.is_ok());
90    }
91
92    #[tokio::test]
93    async fn test_get_historical_index_with_start_and_end_time() {
94        let rest_api = test_utils::get_rest_api_with_authentication_from_env();
95        let request = GetHistoricalIndexRequest::new()
96            .market_name("BTC-PERP")
97            .resolution(60)
98            .start_time(Some(chrono::Utc::now()))
99            .end_time(Some(chrono::Utc::now() + chrono::Duration::seconds(1)))
100            .build();
101        let result = rest_api.send(request).await;
102        assert!(result.is_ok());
103    }
104}