f1 0.2.0

Get historical and live Formula 1 (F1) data
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

use crate::historical::get_season;
use crate::{F1Error, Weekend};

pub struct Season {
    year: i32,
    pub weekends: Vec<Weekend>,
}

impl Season {
    pub fn new(year: i32) -> Result<Self, F1Error> {
        Ok(Self {
            year,
            weekends: get_season(year)?
                .into_iter()
                .map(std::convert::Into::into)
                .collect(),
        })
    }
}

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

    #[test]
    fn test_bahrain_2021_quali() {
        let season = Season::new(2021).unwrap();
        let bahrain = season.weekends.first().unwrap();

        let circuit = &bahrain.circuit;
        assert_eq!(circuit.name, "Bahrain International Circuit");
        assert_eq!(circuit.locality, "Sakhir");
        assert_eq!(circuit.country, "Bahrain");
        assert_eq!(circuit.latitude, 26.0325);
        assert_eq!(circuit.longitude, 50.5106);

        let quali = bahrain.sessions.first().unwrap();

        assert_eq!(quali.standings[0].driver.screen_name, "VER");
        assert_eq!(quali.standings[0].position, 1);
        assert_eq!(
            quali.standings[0].lap_time,
            NaiveTime::from_hms_milli(0, 1, 28, 997)
        );

        assert_eq!(quali.standings[10].driver.screen_name, "PER");
        assert_eq!(quali.standings[10].position, 11);
        assert_eq!(
            quali.standings[10].lap_time,
            NaiveTime::from_hms_milli(0, 1, 30, 659)
        );
    }

    #[test]
    fn test_bahrain_2021_race() {
        let season = Season::new(2021).unwrap();
        let bahrain = season.weekends.first().unwrap();

        let race = bahrain.sessions.last().unwrap();

        assert_eq!(race.standings[0].driver.screen_name, "HAM");
        assert_eq!(race.standings[0].position, 1);
        assert_eq!(
            race.standings[0].lap_time,
            NaiveTime::from_hms_milli(0, 1, 34, 015)
        );

        assert_eq!(race.standings[1].driver.screen_name, "VER");
        assert_eq!(race.standings[1].position, 2);
        assert_eq!(
            race.standings[1].lap_time,
            NaiveTime::from_hms_milli(0, 1, 33, 228)
        );
    }

    #[test]
    fn test_2021_season() {
        let season = Season::new(2021).unwrap();
        assert_eq!(season.year, 2021);

        let first_race = season.weekends.first().unwrap();
        assert_eq!(first_race.name, "Bahrain Grand Prix");
        assert_eq!(
            first_race.sessions.first().unwrap().r#type,
            SessionType::Qualifying
        );
        assert_eq!(
            first_race.sessions.last().unwrap().r#type,
            SessionType::Race
        );
    }
}