gflights 0.3.0

Unofficial async Rust client for the Google Flights web API — search flights, price graphs, and booking offers.
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
150
151
152
153
154
155
156

use std::sync::{Arc, Mutex};

use anyhow::{anyhow, Result};

use crate::parsers::flight_response::{FlightInfo, ItineraryContainer};

/// Fixed flights is a vector of ItineraryContainer.
/// It has a maximum number of elements, defined by the type of flight that needs to be searched.
///
/// Uses a standard [`std::sync::Mutex`] because all call sites hold the guard only briefly
/// and no async code yields while the lock is held.
#[derive(Clone, Debug)]
pub struct FixedFlights {
    flights: Arc<Mutex<Vec<ItineraryContainer>>>,
    max_elements: usize,
}

impl Default for FixedFlights {
    fn default() -> Self {
        Self::new(2_usize)
    }
}

impl FixedFlights {
    pub fn new(max_elements: usize) -> Self {
        FixedFlights {
            flights: Arc::new(Mutex::new(Vec::new())),
            max_elements,
        }
    }

    pub fn add_element(&self, element: ItineraryContainer) -> Result<()> {
        if self.is_full() {
            return Err(anyhow!("Vector max number of elements reached"));
        }

        let mut flights = match self.flights.try_lock() {
            Ok(guard) => guard,
            Err(_) => return Err(anyhow!("Failed to acquire lock")),
        };
        flights.push(element);
        Ok(())
    }

    pub fn maybe_get_nth_flight_info(&self, nth: usize) -> Option<Vec<FlightInfo>> {
        let flights = match self.flights.try_lock() {
            Ok(guard) => guard,
            Err(_) => {
                tracing::warn!("FixedFlights mutex was poisoned; returning None");
                return None;
            }
        };
        flights.get(nth).map(|f| f.itinerary.flight_details.clone())
    }

    pub fn is_full(&self) -> bool {
        let flights = match self.flights.try_lock() {
            Ok(guard) => guard,
            Err(_) => {
                tracing::warn!("FixedFlights mutex was poisoned; assuming not full");
                return false;
            }
        };
        flights.len() >= self.max_elements
    }

    pub fn get_departure_token(&self) -> Option<String> {
        let flights = match self.flights.try_lock() {
            Ok(guard) => guard,
            Err(_) => {
                tracing::warn!("FixedFlights mutex was poisoned; returning None");
                return None;
            }
        };
        let length = flights.len().checked_sub(1)?;
        flights.get(length).map(|f| f.get_departure_token())
    }
}

#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
    use crate::parsers::flight_response::{Itinerary, ItineraryCost};

    use super::*;

    #[test]
    fn fixed_flights_add_element_enforces_max() {
        let ff = FixedFlights::new(1);
        let dummy = || ItineraryContainer {
            itinerary: Itinerary {
                flight_by: "XX".to_owned(),
                flight_details: vec![],
                total_time_minutes: 0,
                connection_info: None,
                emissions: None,
            },
            itinerary_cost: ItineraryCost {
                departure_token: "tok".to_owned(),
                trip_cost: None,
            },
            departure_protobuf: String::new(),
        };
        assert!(ff.add_element(dummy()).is_ok());
        assert!(ff.is_full());
        assert!(ff.add_element(dummy()).is_err());
    }

    #[test]
    fn fixed_flights_get_departure_token_returns_last() {
        let ff = FixedFlights::new(2);
        let make = |tok: &str| ItineraryContainer {
            itinerary: Itinerary {
                flight_by: "XX".to_owned(),
                flight_details: vec![],
                total_time_minutes: 0,
                connection_info: None,
                emissions: None,
            },
            itinerary_cost: ItineraryCost {
                departure_token: tok.to_owned(),
                trip_cost: None,
            },
            departure_protobuf: String::new(),
        };
        assert_eq!(ff.get_departure_token(), None);
        ff.add_element(make("first_token")).unwrap();
        assert_eq!(ff.get_departure_token(), Some("first_token".to_owned()));
        ff.add_element(make("second_token")).unwrap();
        assert_eq!(ff.get_departure_token(), Some("second_token".to_owned()));
    }

    #[test]
    fn fixed_flights_maybe_get_nth_flight_info() {
        let ff = FixedFlights::new(2);
        assert!(ff.maybe_get_nth_flight_info(0).is_none());
        let dummy = ItineraryContainer {
            itinerary: Itinerary {
                flight_by: "BA".to_owned(),
                flight_details: vec![],
                total_time_minutes: 120,
                connection_info: None,
                emissions: None,
            },
            itinerary_cost: ItineraryCost {
                departure_token: "tok".to_owned(),
                trip_cost: None,
            },
            departure_protobuf: String::new(),
        };
        ff.add_element(dummy).unwrap();
        let info = ff.maybe_get_nth_flight_info(0);
        assert!(info.is_some());
        assert_eq!(info.unwrap().len(), 0);
    }
}