Google Flights MCP, CLI and Python Library
"""Tests for SearchFlights._parse_flights_data against synthetic fixtures.
The fixtures here mirror the real Google Flights response structure observed
in `.reverse-eng/notes/response_map.md` (captured live in May 2026). Keeping
them as in-test constants avoids large committed binary blobs while still
locking down the parser positions we depend on.
"""
import pytest
from fli.models import Airline, Airport, SeatType
from fli.search.flights import SearchFlights
def _leg(
*,
dep_iata,
arr_iata,
dep_name="From Airport",
arr_name="To Airport",
dep_time=(20, 25),
arr_time=(23, 43),
duration=378,
aircraft="Boeing 767",
legroom_short="31 in",
legroom_long="31 inches",
airline_code="DL",
flight_number="752",
operating_code=None,
airline_name="Delta",
dep_date=(2026, 7, 15),
arr_date=(2026, 7, 15),
co2=224716,
# leg[32] is an undecoded field that takes values 1/2/3 with no
# relation to the cabin — economy legs in the captured fixtures carry
# all three. The per-leg cabin lives at leg[16] (``cabin`` below).
field_32=2,
cabin=None,
overnight=False,
amenities=None,
legroom_rating=None,
):
amenities = amenities or [None] * 12
leg = [None] * 33
leg[3] = dep_iata
leg[4] = dep_name
leg[5] = arr_name
leg[6] = arr_iata
leg[8] = list(dep_time)
leg[10] = list(arr_time)
leg[11] = duration
leg[12] = amenities
leg[13] = legroom_rating
leg[14] = legroom_short
leg[16] = cabin
leg[17] = aircraft
leg[19] = overnight
leg[20] = list(dep_date)
leg[21] = list(arr_date)
leg[22] = [airline_code, flight_number, operating_code, airline_name]
leg[25] = 1
leg[30] = legroom_long
leg[31] = co2
leg[32] = field_32
return leg
def _row(
*,
legs,
price=164,
currency_token=None,
co2_this=225000,
co2_typ=355000,
co2_worst=390000,
co2_delta_pct=-37,
co2_tag=1,
self_transfer=False,
mixed_cabin=False,
layovers_block=None,
primary_airline_code="DL",
primary_airline_name="Delta",
booking_token="CAISA1VTRBoDCNR/sample",
):
detail = [None] * 25
detail[0] = primary_airline_code
detail[1] = [primary_airline_name]
detail[2] = legs
detail[3] = legs[0][3]
detail[4] = legs[0][20]
detail[5] = legs[0][8]
detail[6] = legs[-1][6]
detail[7] = legs[-1][21]
detail[8] = legs[-1][10]
detail[9] = sum(leg[11] for leg in legs)
detail[12] = self_transfer
detail[13] = layovers_block
emissions = [None] * 18
emissions[3] = co2_delta_pct
emissions[7] = co2_this
emissions[8] = co2_typ
emissions[10] = co2_worst
emissions[11] = co2_tag
detail[22] = emissions
row = [None] * 11
row[0] = detail
row[1] = [[None, price], currency_token]
row[8] = booking_token
row[10] = mixed_cabin
return row
class TestParseFlightsDataNonStop:
"""A baseline non-stop flight parses every rich field correctly."""
def setup_method(self):
self.row = _row(
legs=[
_leg(
dep_iata="JFK",
arr_iata="LAX",
# Slot 1 = AC-outlet-and-USB power, slot 9 = on-demand
# seatback video, slot 11 = free Wi-Fi. Only one slot in
# 1..6 and one in 8..10 is ever set on a real leg.
amenities=[None, True, None, None, None, None, None, None, None, True, None, 2],
legroom_rating=3,
)
],
)
self.flight = SearchFlights._parse_flights_data(self.row)
def test_price_and_basics(self):
assert self.flight.price == 164.0
assert self.flight.duration == 378
assert self.flight.stops == 0
assert len(self.flight.legs) == 1
def test_leg_airports_and_airline(self):
leg = self.flight.legs[0]
assert leg.airline == Airline.DL
assert leg.flight_number == "752"
assert leg.departure_airport == Airport.JFK
assert leg.arrival_airport == Airport.LAX
assert leg.departure_airport_name == "From Airport"
assert leg.arrival_airport_name == "To Airport"
def test_leg_aircraft_legroom(self):
leg = self.flight.legs[0]
assert leg.aircraft == "Boeing 767"
assert leg.legroom == "31 inches"
assert leg.legroom_short == "31 in"
def test_leg_co2(self):
assert self.flight.legs[0].co2_emissions_g == 224716
def test_leg_amenities_populated(self):
am = self.flight.legs[0].amenities
assert am is not None
assert am.wifi is True
assert am.power is True
assert am.on_demand_video is True
assert am.legroom_rating == 3
assert am.usb_power is True
assert am.in_seat_video is True
assert am.wifi_tier == "free"
assert am.power_type == "plug_and_usb"
assert am.video_type == "on_demand"
assert am.seat_quality == "above_average"
assert am.legroom_inches == 31
def test_result_emissions(self):
assert self.flight.co2_emissions_g == 225000
assert self.flight.co2_emissions_typical_g == 355000
assert self.flight.co2_emissions_delta_pct == -37
assert self.flight.emissions_tag == "lower"
def test_no_layovers_for_nonstop(self):
assert self.flight.layovers is None
def test_primary_airline(self):
assert self.flight.primary_airline == Airline.DL
assert self.flight.primary_airline_name == "Delta"
def test_booking_token(self):
assert self.flight.booking_token == "CAISA1VTRBoDCNR/sample"
class TestCabinCode:
"""``leg[16]`` decodes to SeatType; ``leg[32]`` is unrelated to it."""
@pytest.mark.parametrize(
("code", "expected"),
[
(1, SeatType.ECONOMY),
(2, SeatType.PREMIUM_ECONOMY),
(3, SeatType.BUSINESS),
(4, SeatType.FIRST),
],
)
def test_decodes_each_cabin_code(self, code, expected):
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX", cabin=code)])
assert SearchFlights._parse_flights_data(row).legs[0].cabin is expected
@pytest.mark.parametrize("code", [None, 0, 5, 99, -1, True, "3", 2.0])
def test_absent_or_unknown_codes_give_none(self, code):
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX", cabin=code)])
assert SearchFlights._parse_flights_data(row).legs[0].cabin is None
def test_field_32_is_not_the_cabin(self):
"""leg[32] must not leak into ``cabin``.
It holds 1/2/3 on economy legs throughout the captured fixtures,
so reading it as a cabin code would mislabel most of the corpus.
"""
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX", field_32=3, cabin=None)])
assert SearchFlights._parse_flights_data(row).legs[0].cabin is None
class TestLegroomRating:
@pytest.mark.parametrize("rating", range(1, 10))
@pytest.mark.parametrize("wifi_tier", [2, 3])
def test_reads_seat_quality_independently_of_wifi(self, rating, wifi_tier):
amenities = [None] * 12
amenities[11] = wifi_tier
row = _row(
legs=[
_leg(
dep_iata="JFK",
arr_iata="LAX",
amenities=amenities,
legroom_rating=rating,
)
]
)
flight = SearchFlights._parse_flights_data(row)
assert flight.legs[0].amenities.legroom_rating == rating
@pytest.mark.parametrize("slots", [None, [], "invalid"])
def test_preserves_rating_without_amenities_array(self, slots):
leg = _leg(dep_iata="JFK", arr_iata="LAX", legroom_rating=3)
leg[12] = slots
flight = SearchFlights._parse_flights_data(_row(legs=[leg]))
assert flight.legs[0].amenities.legroom_rating == 3
assert flight.legs[0].amenities.wifi is None
@pytest.mark.parametrize("rating", [None, -1, True, "3"])
def test_missing_or_invalid_rating_does_not_fall_back_to_wifi(self, rating):
amenities = [None] * 12
amenities[1] = True
amenities[11] = 2
row = _row(
legs=[
_leg(
dep_iata="JFK",
arr_iata="LAX",
amenities=amenities,
legroom_rating=rating,
)
]
)
flight = SearchFlights._parse_flights_data(row)
assert flight.legs[0].amenities.legroom_rating is None
class TestParseFlightsDataLayover:
"""A multi-leg trip derives layover info from leg timestamps."""
def setup_method(self):
leg1 = _leg(
dep_iata="JFK",
arr_iata="CDG",
dep_time=(19, 15),
arr_time=(9, 5),
dep_date=(2026, 7, 15),
arr_date=(2026, 7, 16),
duration=470,
airline_code="DL",
flight_number="262",
aircraft="Boeing 767",
)
leg2 = _leg(
dep_iata="CDG",
arr_iata="ATH",
dep_time=(13, 20),
arr_time=(17, 40),
dep_date=(2026, 7, 16),
arr_date=(2026, 7, 16),
duration=200,
airline_code="AF",
flight_number="1832",
aircraft="Airbus A321",
)
self.row = _row(
legs=[leg1, leg2],
price=618,
co2_this=625000,
co2_typ=533000,
co2_delta_pct=17,
co2_tag=3,
primary_airline_code="DL",
primary_airline_name="Delta",
)
self.flight = SearchFlights._parse_flights_data(self.row)
def test_stops_count(self):
assert self.flight.stops == 1
def test_layovers_present(self):
assert self.flight.layovers is not None
assert len(self.flight.layovers) == 1
def test_layover_airport_and_duration(self):
lo = self.flight.layovers[0]
assert lo.airport == Airport.CDG
# 13:20 - 09:05 = 4h15 = 255 minutes
assert lo.duration == 255
def test_layover_overnight_flag(self):
# Arrival 2026-07-16 09:05; departure 2026-07-16 13:20 (same day)
assert self.flight.layovers[0].overnight is False
def test_layover_change_of_airport_flag(self):
# Same airport (CDG -> CDG)
assert self.flight.layovers[0].change_of_airport is False
def test_emissions_tag_higher(self):
assert self.flight.emissions_tag == "higher"
assert self.flight.co2_emissions_delta_pct == 17
class TestLayoverDetailBlockEnrichment:
"""``_derive_layovers`` merges city / airport_name from ``detail[13]`` when present."""
def _build_row(self, layovers_block):
leg1 = _leg(
dep_iata="JFK",
arr_iata="CDG",
dep_date=(2026, 7, 15),
arr_date=(2026, 7, 16),
dep_time=(22, 0),
arr_time=(9, 5),
duration=395,
airline_code="DL",
flight_number="100",
airline_name="Delta",
)
leg2 = _leg(
dep_iata="CDG",
arr_iata="FRA",
dep_date=(2026, 7, 16),
arr_date=(2026, 7, 16),
dep_time=(13, 20),
arr_time=(15, 0),
duration=100,
airline_code="AF",
flight_number="200",
airline_name="Air France",
)
return _row(legs=[leg1, leg2], layovers_block=layovers_block)
def test_city_and_airport_name_populated(self):
# Google's detail[13] layover entry:
# [duration_mins, IATA, IATA, None, airport_name, city, ...]
row = self._build_row(
layovers_block=[[255, "CDG", "CDG", None, "Charles de Gaulle Airport", "Paris"]],
)
flight = SearchFlights._parse_flights_data(row)
assert flight.layovers is not None
lo = flight.layovers[0]
assert lo.airport_name == "Charles de Gaulle Airport"
assert lo.city == "Paris"
def test_missing_entry_yields_none_fields(self):
"""detail[13] absent ⇒ derived layover has both enrichment fields as None."""
row = self._build_row(layovers_block=None)
flight = SearchFlights._parse_flights_data(row)
lo = flight.layovers[0]
assert lo.airport_name is None
assert lo.city is None
def test_malformed_entry_does_not_raise(self):
"""A None or empty entry in detail[13] is tolerated."""
for bad in ([None], [[]], [["only-one-element"]]):
row = self._build_row(layovers_block=bad)
flight = SearchFlights._parse_flights_data(row)
lo = flight.layovers[0]
assert lo.airport_name is None
assert lo.city is None
class TestParseFlightsDataDefensive:
"""Parser handles missing optional fields without raising."""
def test_missing_emissions_block(self):
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX")])
# Wipe the emissions block to simulate older / partial responses.
row[0][22] = None
flight = SearchFlights._parse_flights_data(row)
assert flight.co2_emissions_g is None
assert flight.emissions_tag is None
def test_missing_booking_token(self):
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX")])
row[8] = None
flight = SearchFlights._parse_flights_data(row)
assert flight.booking_token is None
def test_missing_amenities_slot(self):
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX", amenities=[])])
flight = SearchFlights._parse_flights_data(row)
assert flight.legs[0].amenities is None
def test_missing_operating_carrier(self):
# Operating code at airline_info[2] = None is the common case.
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX")])
flight = SearchFlights._parse_flights_data(row)
assert flight.legs[0].operating_airline is None
class TestParseFlightsDataEmptyPriceHead:
"""Issue #165 regression: empty price head ``[[], "<token>"]``.
Google emits this for some round-trip premium-cabin rows (notably
multi-pax BUSINESS / FIRST searches) — the row is fully valid; the
aggregate price is simply not pre-computed. The parser should
surface the row with ``price=None`` and keep the rest of the fields
intact, rather than dropping it as malformed.
"""
SHOPPING_TOKEN = (
# Real captured token; encodes USD as the currency.
"CjRIQktCNmV1UjNqNjhBR043X0FCRy0tLS0tLS0tLS12dGpkN0FBQUFBR25JcWZNS2pGTTBBEgZV"
"QTIyMDkaCgjcWxACGgNVU0Q4HHDcWw=="
)
def _empty_head_row(self):
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX")])
# Replace the default ``[[None, price], token]`` block with the
# premium-RT shape Google emits: empty head, token present.
row[1] = [[], self.SHOPPING_TOKEN]
return row
def test_parses_with_none_price(self):
"""Row parses successfully and price is None (not 0.0, not raised)."""
flight = SearchFlights._parse_flights_data(self._empty_head_row())
assert flight.price is None
def test_currency_still_decoded(self):
"""Currency is independent of price head — token decode still runs."""
flight = SearchFlights._parse_flights_data(self._empty_head_row())
assert flight.currency == "USD"
def test_other_fields_intact(self):
"""Routing / duration / booking-token fields unaffected by empty price."""
flight = SearchFlights._parse_flights_data(self._empty_head_row())
assert len(flight.legs) == 1
assert flight.duration > 0
assert flight.booking_token == "CAISA1VTRBoDCNR/sample"
def test_malformed_non_empty_head_still_raises(self):
"""Empty head is OK; a non-empty head with garbage still fails."""
import pytest
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX")])
row[1] = [[None, "not-a-number"], None]
with pytest.raises(ValueError, match="not numeric"):
SearchFlights._parse_flights_data(row)
def test_non_list_head_still_raises(self):
"""Head must be a list — non-list shapes are still malformed."""
import pytest
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX")])
row[1] = ["not-a-list", None]
with pytest.raises(ValueError, match="not a list"):
SearchFlights._parse_flights_data(row)
def test_price_unknown_property_true_when_none(self):
"""Convenience property returns True when price is None."""
flight = SearchFlights._parse_flights_data(self._empty_head_row())
assert flight.price_unknown is True
def test_price_unknown_property_false_when_priced(self):
"""Convenience property returns False for normally-priced rows."""
row = _row(legs=[_leg(dep_iata="JFK", arr_iata="LAX")])
flight = SearchFlights._parse_flights_data(row)
assert flight.price_unknown is False