finnhub 0.2.2

A comprehensive Rust client for the Finnhub.io financial data API with 96% endpoint coverage, flexible rate limiting, and WebSocket support
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Calendar endpoints for earnings, economic events, and IPOs.

use crate::{
    client::FinnhubClient,
    error::Result,
    models::calendar::{EarningsCalendar, EconomicCalendar, IPOCalendar},
};

/// Calendar-related API endpoints.
pub struct CalendarEndpoints<'a> {
    client: &'a FinnhubClient,
}

impl<'a> CalendarEndpoints<'a> {
    /// Create a new calendar endpoints instance.
    pub fn new(client: &'a FinnhubClient) -> Self {
        Self { client }
    }

    /// Get earnings calendar.
    ///
    /// Returns historical and upcoming earnings releases.
    ///
    /// # Arguments
    /// * `from` - From date in YYYY-MM-DD format (optional)
    /// * `to` - To date in YYYY-MM-DD format (optional)
    /// * `symbol` - Filter by symbol (optional)
    pub async fn earnings(
        &self,
        from: Option<&str>,
        to: Option<&str>,
        symbol: Option<&str>,
    ) -> Result<EarningsCalendar> {
        let mut params = vec![];

        if let Some(f) = from {
            params.push(format!("from={}", f));
        }
        if let Some(t) = to {
            params.push(format!("to={}", t));
        }
        if let Some(s) = symbol {
            params.push(format!("symbol={}", s));
        }

        let query = if params.is_empty() {
            String::from("/calendar/earnings")
        } else {
            format!("/calendar/earnings?{}", params.join("&"))
        };

        self.client.get(&query).await
    }

    /// Get economic calendar.
    ///
    /// Returns recent and upcoming economic releases.
    ///
    /// # Arguments
    /// * `from` - From date in YYYY-MM-DD format (optional)
    /// * `to` - To date in YYYY-MM-DD format (optional)
    pub async fn economic(&self, from: Option<&str>, to: Option<&str>) -> Result<EconomicCalendar> {
        let mut params = vec![];

        if let Some(f) = from {
            params.push(format!("from={}", f));
        }
        if let Some(t) = to {
            params.push(format!("to={}", t));
        }

        let query = if params.is_empty() {
            String::from("/calendar/economic")
        } else {
            format!("/calendar/economic?{}", params.join("&"))
        };

        self.client.get(&query).await
    }

    /// Get IPO calendar.
    ///
    /// Returns recent and upcoming IPOs for a date range.
    ///
    /// # Arguments
    /// * `from` - From date in YYYY-MM-DD format
    /// * `to` - To date in YYYY-MM-DD format
    pub async fn ipo(&self, from: &str, to: &str) -> Result<IPOCalendar> {
        self.client
            .get(&format!("/calendar/ipo?from={}&to={}", from, to))
            .await
    }
}

#[cfg(test)]
mod tests {
    use crate::{ClientConfig, FinnhubClient, RateLimitStrategy};

    async fn test_client() -> FinnhubClient {
        dotenv::dotenv().ok();
        let api_key = std::env::var("FINNHUB_API_KEY").unwrap_or_else(|_| "test_key".to_string());

        let mut config = ClientConfig::default();
        config.rate_limit_strategy = RateLimitStrategy::FifteenSecondWindow;
        FinnhubClient::with_config(api_key, config)
    }

    #[tokio::test]
    #[ignore = "requires API key"]
    async fn test_earnings() {
        let client = test_client().await;
        let from = "2024-01-01";
        let to = "2024-01-31";
        let result = client.calendar().earnings(Some(from), Some(to), None).await;
        assert!(
            result.is_ok(),
            "Failed to get earnings calendar: {:?}",
            result.err()
        );
    }

    #[tokio::test]
    #[ignore = "requires API key"]
    async fn test_economic() {
        let client = test_client().await;
        let from = "2024-01-01";
        let to = "2024-01-31";
        let result = client.calendar().economic(Some(from), Some(to)).await;
        assert!(
            result.is_ok(),
            "Failed to get economic calendar: {:?}",
            result.err()
        );
    }

    #[tokio::test]
    #[ignore = "requires API key"]
    async fn test_ipo() {
        let client = test_client().await;
        let from = "2024-01-01";
        let to = "2024-01-31";
        let result = client.calendar().ipo(from, to).await;
        assert!(
            result.is_ok(),
            "Failed to get IPO calendar: {:?}",
            result.err()
        );
    }
}