Google Flights MCP, CLI and Python Library
"""Tests for SearchFlights.get_booking_options encoding + booking-row parsing."""
import json
import urllib.parse
from datetime import datetime, time, timedelta
import pytest
from fli.models import (
Airline,
Airport,
BookingOption,
FlightLeg,
FlightResult,
FlightSearchFilters,
FlightSegment,
PassengerInfo,
TripType,
)
from fli.search.flights import SearchFlights, _try_parse_booking_row
from tests.search._pages import as_search_page
# Segment travel dates are validated against today, so keep the fixtures
# relative — hardcoded dates rot the suite the moment they go past.
OUT_DATE = (datetime.now() + timedelta(days=30)).date()
RET_DATE = OUT_DATE + timedelta(days=4)
def _round_trip_filters():
"""Build a round-trip filter with selected_flight set on both segments."""
leg_out = FlightLeg(
airline=Airline.AA,
flight_number="171",
departure_airport=Airport.JFK,
arrival_airport=Airport.LAX,
departure_datetime=datetime.combine(OUT_DATE, time(6, 0)),
arrival_datetime=datetime.combine(OUT_DATE, time(9, 1)),
duration=361,
)
leg_in = FlightLeg(
airline=Airline.AA,
flight_number="28",
departure_airport=Airport.LAX,
arrival_airport=Airport.JFK,
departure_datetime=datetime.combine(RET_DATE, time(15, 15)),
arrival_datetime=datetime.combine(RET_DATE, time(23, 54)),
duration=339,
)
sel_out = FlightResult(
legs=[leg_out],
price=347,
currency="USD",
duration=361,
stops=0,
)
sel_in = FlightResult(
legs=[leg_in],
price=347,
currency="USD",
duration=339,
stops=0,
)
seg_out = FlightSegment(
departure_airport=[[Airport.JFK, 0]],
arrival_airport=[[Airport.LAX, 0]],
travel_date=OUT_DATE.isoformat(),
selected_flight=sel_out,
)
seg_in = FlightSegment(
departure_airport=[[Airport.LAX, 0]],
arrival_airport=[[Airport.JFK, 0]],
travel_date=RET_DATE.isoformat(),
selected_flight=sel_in,
)
return FlightSearchFilters(
trip_type=TripType.ROUND_TRIP,
passenger_info=PassengerInfo(adults=1),
flight_segments=[seg_out, seg_in],
)
class TestEncodeBookingPayload:
def test_payload_has_token_and_main_struct(self):
filters = _round_trip_filters()
encoded = SearchFlights._encode_booking_payload("TEST-TOKEN", filters)
# Decode the URL-encoded outer JSON.
raw = urllib.parse.unquote(encoded)
outer = json.loads(raw)
# outer[0] is null, outer[1] is the inner-stringified payload.
assert outer[0] is None
payload = json.loads(outer[1])
# outer[0]: [null, token]
assert payload[0] == [None, "TEST-TOKEN"]
# outer[1]: the same main filter struct that FlightSearchFilters.format() emits at [1]
assert isinstance(payload[1], list)
assert payload[1][2] == 1 # trip_type ROUND_TRIP
assert payload[1][6] == [1, 0, 0, 0] # passengers
# outer[2] null and outer[3] 0 are required trailers.
assert payload[2] is None
assert payload[3] == 0
def test_segments_include_selected_flight(self):
filters = _round_trip_filters()
encoded = SearchFlights._encode_booking_payload("T", filters)
payload = json.loads(json.loads(urllib.parse.unquote(encoded))[1])
segments = payload[1][13]
assert len(segments) == 2
# selected_flight legs sit at segment[8]; verify each leg's basic fields.
out_sel = segments[0][8]
assert out_sel == [["JFK", OUT_DATE.isoformat(), "LAX", None, "AA", "171"]]
in_sel = segments[1][8]
assert in_sel == [["LAX", RET_DATE.isoformat(), "JFK", None, "AA", "28"]]
class TestGetBookingOptionsTokenGuard:
def test_raises_when_no_token(self):
filters = _round_trip_filters()
flight = filters.flight_segments[0].selected_flight
# selected_flight has no booking_token, and the client has no
# cached session id (no prior search() call).
with pytest.raises(ValueError, match="Missing booking token"):
SearchFlights().get_booking_options(flight, filters)
class TestGetBookingOptionsPriceless:
"""Issue #165: ``get_booking_options`` works when ``last.price`` is None.
Premium-cabin round-trip rows often come back from the shopping
endpoint without a per-row price. The booking helper must not crash
on ``int(None * 100)`` — instead it should fall through to the
per-row ``booking_token`` captured at parse time.
"""
def test_falls_back_to_per_row_token_when_price_is_none(self):
"""Cached session is present, but last.price=None → use row token."""
from unittest.mock import patch
sf = SearchFlights()
sf._last_session_id = "FAKE_SESSION_ID_PRICELESS"
filters = _round_trip_filters()
# Drop both prices to simulate the premium-RT priceless case.
# Assign the row-level token onto the return leg's
# selected_flight — this is what ``parse_flight_row`` would have
# populated from ``row[8]`` on the live response.
out = filters.flight_segments[0].selected_flight
ret = filters.flight_segments[1].selected_flight
out.price = None
ret.price = None
ret.booking_token = "PER_ROW_TOKEN_FROM_ROW_8"
captured: dict[str, str] = {}
def _fake_post(url, data, **kwargs): # noqa: ANN001
captured["data"] = data
return type(
"R",
(),
{
"content": b")]}'\n\n4\n[[]]\n",
"text": ")]}'\n\n4\n[[]]\n",
"raise_for_status": lambda self: None,
},
)()
with patch.object(sf.client, "post", side_effect=_fake_post):
sf.get_booking_options((out, ret), filters, currency="USD")
body = captured["data"]
assert body.startswith("f.req=")
decoded_body = urllib.parse.unquote(body[len("f.req=") :])
outer = json.loads(decoded_body)
payload = json.loads(outer[1])
# outer[0] = [None, token]; the token should be the per-row
# token, NOT a build_booking_token-generated session blob.
assert payload[0] == [None, "PER_ROW_TOKEN_FROM_ROW_8"]
def test_raises_clear_error_when_priceless_and_no_per_row_token(self):
"""No price AND no per-row token → user gets the actionable error."""
sf = SearchFlights()
sf._last_session_id = "FAKE_SESSION_ID"
filters = _round_trip_filters()
out = filters.flight_segments[0].selected_flight
ret = filters.flight_segments[1].selected_flight
out.price = None
ret.price = None
out.booking_token = None
ret.booking_token = None
with pytest.raises(ValueError, match="Missing booking token"):
sf.get_booking_options((out, ret), filters)
class TestGetBookingOptionsErrorPaths:
"""Booking-flow failure modes: HTTP error, segment mismatch, malformed body."""
def test_http_error_propagates_naturally(self):
"""HTTP failures bubble up unchanged — no wrapping into generic Exception."""
from unittest.mock import patch
sf = SearchFlights()
sf._last_session_id = "S"
filters = _round_trip_filters()
flight = filters.flight_segments[1].selected_flight
class FakeHTTPError(RuntimeError):
pass
def _boom(*args, **kwargs):
raise FakeHTTPError("network down")
with patch.object(sf.client, "post", side_effect=_boom):
with pytest.raises(FakeHTTPError, match="network down"):
sf.get_booking_options(flight, filters)
def test_more_results_than_segments_rejected(self):
"""Caller passes a 3-tuple against 2-segment filters → ValueError."""
filters = _round_trip_filters() # 2 segments
# Build a 3-tuple of flight results.
f = filters.flight_segments[0].selected_flight
oversized = (f, f, f)
sf = SearchFlights()
sf._last_session_id = "S"
with pytest.raises(ValueError, match="3 segments but filters has 2"):
sf.get_booking_options(oversized, filters)
def test_malformed_body_returns_empty_options(self):
"""Garbage body still allows the call to complete with an empty list.
This is the documented contract — the wire parser yields zero
chunks for unrecognised bodies, so callers get ``[]`` rather than
an exception when Google reshapes the response.
"""
from unittest.mock import patch
sf = SearchFlights()
sf._last_session_id = "S"
filters = _round_trip_filters()
flight = filters.flight_segments[1].selected_flight
def _fake_post(url, data, **kwargs): # noqa: ANN001
return type(
"R",
(),
{
"content": b"garbage-no-prefix",
"text": "garbage-no-prefix",
"raise_for_status": lambda self: None,
},
)()
with patch.object(sf.client, "post", side_effect=_fake_post):
opts = sf.get_booking_options(flight, filters, currency="USD")
assert opts == []
class TestGetBookingOptionsRejectionEnvelope:
"""A declined booking call must not read as "no bookable fares".
Google answers a request it refuses with ``HTTP 200`` and a payload-less
``wrb.fr`` row carrying a gRPC status. That used to yield zero chunks,
which is indistinguishable from an itinerary nobody sells — so the wire
reader raises :class:`SearchRejectedError` instead, and it has to reach
the caller through ``get_booking_options`` unchanged.
"""
@staticmethod
def _canned(body: str):
"""Return a client plus a patch making its booking POST answer ``body``.
``sf.client`` is a process-wide singleton, so the patch is handed
back as a context manager rather than started here — a leaked patch
feeds this canned body to every later test.
"""
from unittest.mock import patch
def _fake_post(url, data, **kwargs): # noqa: ANN001
return type(
"R",
(),
{
"content": body.encode("utf-8"),
"text": body,
"raise_for_status": lambda self: None,
},
)()
sf = SearchFlights()
sf._last_session_id = "S"
return sf, patch.object(sf.client, "post", side_effect=_fake_post)
def test_error_envelope_raises_instead_of_returning_no_options(self):
"""HTTP 200 + error envelope surfaces the status code, not an empty list."""
from fli.search import SearchRejectedError
body = ")]}'\n\n" + json.dumps(
[
["wrb.fr", None, None, None, None, [13]],
["di", 39],
["af.httprm", 38, "-1963517503", 5],
]
)
filters = _round_trip_filters()
flight = filters.flight_segments[1].selected_flight
sf, patcher = self._canned(body)
with patcher, pytest.raises(SearchRejectedError, match=r"13 \(INTERNAL\)") as excinfo:
sf.get_booking_options(flight, filters, currency="USD")
assert excinfo.value.code == 13
def test_rejection_reaches_the_cli_and_mcp_friendly_messages(self, monkeypatch, tmp_path):
"""The typed error stays classified, not an "unexpected error"."""
from fli.cli.errors import _friendly_message, json_error_payload
from fli.core.errors import classify_error
from fli.mcp.server import _search_error_message
from fli.search import SearchRejectedError
# ``json_error_payload`` writes a real traceback file. Send it to
# tmp_path instead of the user's ~/.fli/logs, the way the autouse
# fixture in tests/cli/test_errors.py does for the same helper.
log_dir = tmp_path / "fli-logs"
monkeypatch.setattr("fli.cli.errors._LOG_DIR", log_dir)
exc = SearchRejectedError(13, detail="req-abc123")
assert "declined the request" in _friendly_message(exc)
assert "Unexpected error" not in _friendly_message(exc)
assert "declined the request" in _search_error_message(exc)
# Both surfaces classify it through the shared classifier, so they
# have to agree — a rejection is deterministic and never retryable.
payload = json_error_payload(exc, command="flights")
assert payload.error_type == "rejected_error"
assert payload.retryable is False
mcp_fields = classify_error(exc).as_fields()
assert mcp_fields["error_type"] == "rejected_error"
assert mcp_fields["retryable"] is False
assert list(log_dir.iterdir()), "the log file should have landed under tmp_path"
def test_genuinely_empty_response_still_returns_no_options(self):
"""A well-formed response with no vendor rows keeps returning []."""
inner = json.dumps([[], None], separators=(",", ":"))
body = ")]}'\n\n" + json.dumps([["wrb.fr", None, inner]])
filters = _round_trip_filters()
flight = filters.flight_segments[1].selected_flight
sf, patcher = self._canned(body)
with patcher:
assert sf.get_booking_options(flight, filters, currency="USD") == []
class TestEncodeBookingPayloadValidation:
"""``_encode_booking_payload`` rejects filters that can't produce a main struct."""
def test_raises_when_filters_format_returns_no_main(self):
"""Patching the class method (Pydantic instances are frozen-ish)."""
from unittest.mock import patch
filters = _round_trip_filters()
with patch.object(type(filters), "format", lambda self: [None]):
with pytest.raises(ValueError, match="did not return a main struct"):
SearchFlights._encode_booking_payload("TOKEN", filters)
def test_raises_when_main_is_not_a_list(self):
"""If format()[1] is a non-list value, the encoder still rejects loudly."""
from unittest.mock import patch
filters = _round_trip_filters()
with patch.object(type(filters), "format", lambda self: [None, "not-a-list"]):
with pytest.raises(ValueError, match="did not return a main struct"):
SearchFlights._encode_booking_payload("TOKEN", filters)
class TestGetBookingOptionsSessionCaching:
def test_search_caches_session_id_on_client(self):
"""`search` populates `_last_session_id` from the response."""
from unittest.mock import patch
from fli.search.flights import SearchFlights
sf = SearchFlights()
# Fake a response whose ``inner[0][4]`` is a session id string.
fake_inner = [
[None, None, None, None, "HCAPTUREDSESSIONID----123ABC"],
None,
None,
[
[
[
[None] * 25 + [None], # detail block (unused)
]
],
None,
None,
None,
None,
],
]
# Serve it the way the page transport reads it: a ds:1 blob.
body = as_search_page(fake_inner)
with patch.object(sf.client, "get") as mock_get:
mock_response = type("R", (), {"text": body, "raise_for_status": lambda s: None})()
mock_get.return_value = mock_response
try:
sf.search(_round_trip_filters())
except Exception:
# Parser will reject the fake flights — that's OK; we only
# care about the session-id capture side effect.
pass
assert sf._last_session_id == "HCAPTUREDSESSIONID----123ABC"
def test_get_booking_options_uses_cached_session_id(self):
"""Cached session id flows into the protobuf token builder.
We mock the HTTP layer and inspect the request body — the token
embedded at outer[0][1] should decode to a protobuf whose
``field 1`` is the cached session id.
"""
from unittest.mock import patch
from fli.search._proto import decode_booking_token
from fli.search.flights import SearchFlights
sf = SearchFlights()
sf._last_session_id = "FAKE_SESSION_ID_12345"
filters = _round_trip_filters()
flight = filters.flight_segments[1].selected_flight # return leg
captured_body = {}
def _fake_post(url, data, **kwargs): # noqa: ANN001
captured_body["data"] = data
return type(
"R",
(),
{
"content": b")]}'\n\n4\n[[]]\n",
"text": ")]}'\n\n4\n[[]]\n",
"raise_for_status": lambda self: None,
},
)()
with patch.object(sf.client, "post", side_effect=_fake_post):
sf.get_booking_options(flight, filters, currency="USD")
# Extract token from the URL-encoded body
body = captured_body["data"]
assert body.startswith("f.req=")
decoded_body = urllib.parse.unquote(body[len("f.req=") :])
outer = json.loads(decoded_body)
payload = json.loads(outer[1])
token = payload[0][1]
decoded = decode_booking_token(token)
assert decoded["field_1"] == "FAKE_SESSION_ID_12345"
def _row(price=347, fare_label="Basic Economy"):
"""Build a booking row with positional fields matching the live capture."""
row = [None] * 22
row[0] = 0
row[1] = [["AA", "American", None, True]]
row[2] = None
row[3] = [["AA", "171"], ["AA", "28"]]
row[4] = False
row[5] = ["www.aa.com/foo", None, ["https://www.google.com/travel/clk/f?u=abc"]]
row[7] = [[None, price], None] # price block; currency token omitted
row[14] = [[[None, ["AA", fare_label.upper().replace(" ", " ")], 1]]]
row[21] = [["AA", fare_label.upper()], [], None, fare_label]
return row
class TestParseBookingRow:
def test_basic_row(self):
opt = _try_parse_booking_row(_row())
assert isinstance(opt, BookingOption)
assert opt.vendor_code == "AA"
assert opt.vendor_name == "American"
assert opt.is_airline_direct is True
assert opt.flights == [("AA", "171"), ("AA", "28")]
assert opt.booking_url == "www.aa.com/foo"
assert opt.google_click_url == "https://www.google.com/travel/clk/f?u=abc"
def test_extracts_price_from_row7(self):
opt = _try_parse_booking_row(_row(price=457))
assert opt is not None
assert opt.price == 457.0
def test_extracts_fare_name_from_row21(self):
opt = _try_parse_booking_row(_row(fare_label="Main Cabin"))
assert opt is not None
assert opt.fare_name == "Main Cabin"
def test_rejects_non_booking_list(self):
# Random outer list — should not falsely parse.
assert _try_parse_booking_row([1, 2, 3]) is None
def test_rejects_short_list(self):
assert _try_parse_booking_row([0, [["AA", "American"]]]) is None
def test_rejects_when_first_not_int(self):
row = _row()
row[0] = "not-an-int"
assert _try_parse_booking_row(row) is None
class TestParseBookingChunk:
def test_walks_nested_lists(self):
# Build full-shape rows so the positional parser matches them.
row_aa = _row(price=347, fare_label="Basic Economy")
row_ex = _row(price=400, fare_label="Refundable")
row_ex[1] = [["EX", "Expedia", None, False]]
chunk = [None, [row_aa, row_ex]]
opts = SearchFlights._parse_booking_chunk(chunk)
assert len(opts) == 2
assert {o.vendor_code for o in opts} == {"AA", "EX"}
# Order from the parser walk preserves chunk order.
by_vendor = {o.vendor_code: o for o in opts}
assert by_vendor["AA"].is_airline_direct is True
assert by_vendor["EX"].is_airline_direct is False