brasilapi 0.8.0

Uma lib para a API do Brasil 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
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

use crate::{error::*, spec::BRASIL_API_URL};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
pub struct Holiday {
    pub date: String,
    #[serde(rename = "type")]
    pub kind: String,
    pub name: String,
    pub full_name: Option<String>,
}

pub struct HolidayService {
    base_url: String,
}

impl HolidayService {
    pub fn new(base_url: &str) -> Self {
        Self {
            base_url: base_url.to_string(),
        }
    }

    async fn get_holiday_request(&self, year: &str) -> Result<reqwest::Response, Error> {
        let url = format!("{}/api/feriados/v1/{}", self.base_url, year);

        match reqwest::get(&url).await {
            Ok(response) => Error::from_response(response).await,
            Err(e) => Err(Error::from_error(e)),
        }
    }
}

/// #### `get_holidays(year: &str)`
/// Lista os feriados nacionais de determinado ano.
///
/// ### Argumento
/// * `year:&str` => Ano para calcular os feriados.
///
/// ### Retorno
/// * `Result<Vec<Holiday>, Error>`
///
/// # Exemplo
///  ```
/// use brasilapi::holidays;
/// use brasilapi::holidays::Holiday;
///
/// #[tokio::main]
/// async fn main() {
///     let holidays:Vec<Holiday> = holidays::get_holidays("2022").await.unwrap();
/// }
/// ```
pub async fn get_holidays(year: &str) -> Result<Vec<Holiday>, Error> {
    let holiday_service = HolidayService::new(BRASIL_API_URL);

    let response = holiday_service.get_holiday_request(year).await?;

    let body = response.text().await.unwrap();
    let holidays: Vec<Holiday> = serde_json::from_str(&body).unwrap();

    Ok(holidays)
}

/// #### `get_holiday(year: &str, month: &str, day: &str)`
/// Retorna um feriado a partir de uma data.
///
/// ### Argumento
/// * `year:&str`   => Ano do feriado.
/// * `month:&str`  => Mês do feriado.
/// * `day:&str`    => Dia do feriado.
///
/// ### Retorno
/// * `Result<Holiday, Error>`
///
/// # Example
/// ```
/// use brasilapi::holidays;
/// use brasilapi::holidays::Holiday;
///
/// #[tokio::main]
/// async fn main() {
///     let holiday:Holiday = holidays::get_holiday("2022", "09", "07").await.unwrap();
/// }
/// ```
pub async fn get_holiday(year: &str, month: &str, day: &str) -> Result<Holiday, Error> {
    let holidays = get_holidays(year).await?;

    let holiday_position = holidays
        .iter()
        .position(|holiday| holiday.date == format!("{year}-{month}-{day}"));

    match holiday_position {
        Some(position) => Ok(holidays.get(position).unwrap().clone()),
        None => Err(Error::new(
            String::from("holiday not found"),
            Errored::NotFound,
            Some(404),
        )),
    }
}

#[cfg(test)]
mod holidays_tests {
    use super::*;

    #[tokio::test]
    async fn get_holidays_test() {
        let holidays = get_holidays("2022").await.unwrap();

        let holyday = get_holiday("2022", "01", "01").await.unwrap();

        assert!(holidays.contains(&holyday));
    }

    #[tokio::test]
    async fn get_holidays_error_test() {
        let holidays = get_holidays("2").await;

        assert!(holidays.is_err());
    }

    #[tokio::test]
    async fn get_holiday_test() {
        let holiday = get_holiday("2022", "09", "07").await.unwrap();

        assert_eq!(holiday.name, "Independência do Brasil");
    }

    #[tokio::test]
    async fn get_holiday_error_test() {
        let holiday = get_holiday("2022", "10", "02").await;

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