avios-cli 0.4.1__tar.gz → 0.4.2__tar.gz

{avios_cli-0.4.1 → avios_cli-0.4.2}/CHANGELOG.md

@@ -6,6 +6,17 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.4.2] - 2026-07-27
+
+### Fixed
+- **BA reward-flight searches failed with 403 after a successful login.** The
+  flight finder has a separate Auth0 session and rejects plain HTTP or automated
+  headless requests at Akamai. BA login now waits for the second reward-flight
+  prompt, and searches drive the site's own form in a background Chrome window
+  before parsing the returned RSC availability.
+- Stored Akamai cookies are no longer replayed over Chrome's fresher browser jar,
+  and a transient Next.js shell response is retried once.
+
 ## [0.4.1] - 2026-07-27
 
 ### Fixed
@@ -187,7 +198,8 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - Reward-flight **availability** search is not yet implemented (needs a British
   Airways capture).
 
-[Unreleased]: https://github.com/alexechoi/avios-cli/compare/v0.4.1...HEAD
+[Unreleased]: https://github.com/alexechoi/avios-cli/compare/v0.4.2...HEAD
+[0.4.2]: https://github.com/alexechoi/avios-cli/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/alexechoi/avios-cli/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/alexechoi/avios-cli/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/alexechoi/avios-cli/compare/v0.2.1...v0.3.0

{avios_cli-0.4.1 → avios_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avios-cli
-Version: 0.4.1
+Version: 0.4.2
 Summary: A CLI and TUI for Avios balances, transactions, and BA reward-flight availability.
 Project-URL: Homepage, https://github.com/alexechoi/avios-cli
 Project-URL: Repository, https://github.com/alexechoi/avios-cli
@@ -128,8 +128,12 @@ for Finnair because browser-cookie import cannot read that token.
 Each programme session is stored at `~/.config/avios/accounts/<programme>.json`
 (mode `600`). Sessions expire; just log in to that programme again. Use
 `avios logout <programme>` for one account or `avios logout` for all accounts.
-For BA, browser-assisted login also opens the reward-flight finder briefly so its
-separate `spend-avios` session is captured.
+For BA, browser-assisted login also opens the separate reward-flight application.
+British Airways may show a second login prompt; keep the browser open until the
+CLI confirms success. Reward searches drive the site's own form in a background
+Chrome window because the flight-search route rejects plain HTTP and automated
+headless requests, so the `login` extra remains required when running
+`avios flights` or the Reward Flights TUI tab.
 
 ## Usage
 

{avios_cli-0.4.1 → avios_cli-0.4.2}/README.md

@@ -93,8 +93,12 @@ for Finnair because browser-cookie import cannot read that token.
 Each programme session is stored at `~/.config/avios/accounts/<programme>.json`
 (mode `600`). Sessions expire; just log in to that programme again. Use
 `avios logout <programme>` for one account or `avios logout` for all accounts.
-For BA, browser-assisted login also opens the reward-flight finder briefly so its
-separate `spend-avios` session is captured.
+For BA, browser-assisted login also opens the separate reward-flight application.
+British Airways may show a second login prompt; keep the browser open until the
+CLI confirms success. Reward searches drive the site's own form in a background
+Chrome window because the flight-search route rejects plain HTTP and automated
+headless requests, so the `login` extra remains required when running
+`avios flights` or the Reward Flights TUI tab.
 
 ## Usage
 

{avios_cli-0.4.1 → avios_cli-0.4.2}/SECURITY.md

@@ -11,8 +11,10 @@
 - `avios logout` deletes stored sessions. They also expire on the server side.
 - `AVIOS_COOKIE` may be set to supply a cookie via the environment instead of the
   stored file — avoid committing it or storing it in shell history.
-- Reward-flight search sends the same saved BA cookie only to `www.avios.com`.
-  The RSC response's short-lived action tokens are neither exposed nor persisted.
+- Reward-flight search launches the isolated BA Chrome profile in the background;
+  Chrome sends the saved application cookie only to `www.avios.com` and refreshes
+  its own anti-bot cookies. The RSC response's short-lived action tokens are
+  neither exposed nor persisted.
 
 ## Unofficial software
 

{avios_cli-0.4.1 → avios_cli-0.4.2}/pyproject.toml

@@ -36,8 +36,8 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-# Browser-assisted login. Kept optional so the core stays lightweight and the
-# heavy Playwright browser download is only pulled when a user needs to log in.
+# Browser-assisted login and BA reward search. Kept optional so account-only
+# commands remain lightweight when a user does not need a browser.
 login = [
     "playwright>=1.44",
     "browser-cookie3>=0.19",

{avios_cli-0.4.1 → avios_cli-0.4.2}/src/avios/__init__.py

@@ -3,4 +3,4 @@
 View your Avios balance, transactions and reward-flight availability from the terminal.
 """
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"

{avios_cli-0.4.1 → avios_cli-0.4.2}/src/avios/auth.py

@@ -33,6 +33,7 @@ from avios.session import cookie_header_from
 LOGIN_TIMEOUT_MS = 300_000  # 5 minutes to complete password + captcha + MFA
 LOGIN_POLL_MS = 2_000  # how often to check whether the session is authenticated
 SUPPORTED_BROWSERS = ("chrome", "firefox", "edge", "brave", "safari", "chromium")
+BA_REWARD_SEARCH_PATH = "/en-GB/spend-avios/search-reward-flights"
 
 # Chromium-family user-data roots per browser (relative to home), used to discover
 # per-profile cookie databases (Default, "Profile 1", ...).
@@ -108,36 +109,67 @@ def login_via_browser(
     profile_dir = str(settings.config_dir / "chrome-profile" / programme.slug)
 
     with factory() as pw:
-        ctx = _open_login_context(pw, headless=headless, user_data_dir=profile_dir)
+        ctx = _open_login_context(
+            pw,
+            headless=headless,
+            user_data_dir=profile_dir,
+            user_agent=settings.user_agent,
+        )
         page = ctx.new_page()
         page.goto(programme.login_url)
         authed = _wait_for_auth(ctx, page, programme.base_url, timeout_ms)
+        reward_authed = True
         if authed and programme.slug == "ba":
-            _warm_ba_reward_search(page, programme.base_url)
+            reward_authed = _wait_for_ba_reward_auth(
+                ctx,
+                page,
+                programme.base_url,
+                timeout_ms,
+            )
         cookies = list(ctx.cookies())
         ctx.close()
 
     if not authed:
         raise LoginError("Timed out waiting for login. Run `avios login` again.")
+    if not reward_authed:
+        raise LoginError(
+            "British Airways account login succeeded, but reward-flight login did not. "
+            "Run `avios login ba` again, complete the second BA prompt, and keep the "
+            "browser open until this command confirms success."
+        )
     return _only_avios(cookies)
 
 
-def _warm_ba_reward_search(page: Any, base_url: str) -> None:
-    """Open BA's separate flight-search app so its session cookies are captured.
+def _has_ba_reward_session(ctx: Any) -> bool:
+    """Whether BA's separate reward-search application session is present."""
+    names = {
+        str(cookie.get("name", ""))
+        for cookie in ctx.cookies()
+        if "avios.com" in str(cookie.get("domain", ""))
+    }
+    return "__session" in names or any(name.startswith("appSession") for name in names)
 
-    Balance/profile authentication alone does not necessarily initialise the
-    ``spend-avios`` Next.js app. This best-effort navigation runs while the real
-    login browser is already open; failure does not invalidate account login.
-    """
+
+def _wait_for_ba_reward_auth(ctx: Any, page: Any, base_url: str, timeout_ms: int) -> bool:
+    """Open BA's reward app and wait for its separate Auth0 flow to complete."""
     try:
         page.goto(
-            f"{base_url}/en-GB/spend-avios/search-reward-flights",
+            f"{base_url}{BA_REWARD_SEARCH_PATH}",
             wait_until="domcontentloaded",
             timeout=60_000,
         )
-        page.wait_for_timeout(3_000)
     except Exception:
-        pass
+        return False
+
+    for _ in range(max(1, timeout_ms // LOGIN_POLL_MS)):
+        if _has_ba_reward_session(ctx) and page.url.startswith(
+            f"{base_url}{BA_REWARD_SEARCH_PATH}"
+        ):
+            with contextlib.suppress(Exception):
+                if "search reward flights" in page.title().lower():
+                    return True
+        page.wait_for_timeout(LOGIN_POLL_MS)
+    return False
 
 
 def _import_sync_playwright() -> Any:
@@ -177,7 +209,14 @@ def _is_authenticated(ctx: Any, base_url: str) -> bool:
         return False
 
 
-def _open_login_context(pw: Any, *, headless: bool, user_data_dir: str) -> Any:
+def _open_login_context(
+    pw: Any,
+    *,
+    headless: bool,
+    user_data_dir: str,
+    user_agent: str | None = None,
+    background: bool = False,
+) -> Any:
     """Open a browser context for login, tuned to avoid the hCaptcha bot loop.
 
     hCaptcha/Akamai serve endless challenges to obviously-automated browsers, so:
@@ -189,6 +228,14 @@ def _open_login_context(pw: Any, *, headless: bool, user_data_dir: str) -> Any:
     """
     args = ["--disable-blink-features=AutomationControlled"]
     ignore_default_args = ["--enable-automation"]
+    launch_options: dict[str, Any] = {}
+    if background:
+        args.append("--window-position=-32000,-32000")
+        launch_options["viewport"] = {"width": 1280, "height": 900}
+    if headless and user_agent:
+        # Chrome's native headless networking can reach BA's login page, but its
+        # default ``HeadlessChrome`` UA is rejected. Keep the normal Chrome UA.
+        launch_options["user_agent"] = user_agent
     for extra in ({"channel": "chrome"}, {}):
         try:
             return pw.chromium.launch_persistent_context(
@@ -196,6 +243,7 @@ def _open_login_context(pw: Any, *, headless: bool, user_data_dir: str) -> Any:
                 headless=headless,
                 args=args,
                 ignore_default_args=ignore_default_args,
+                **launch_options,
                 **extra,
             )
         except Exception:

{avios_cli-0.4.1 → avios_cli-0.4.2}/src/avios/cli.py

@@ -179,9 +179,14 @@ def login(
             account = Account.from_programme(prog, cookies=result.cookies)
             saved_label = f"{result.count} cookie(s){where}"
         else:
+            ba_note = (
+                " British Airways may show a second login prompt for reward flights."
+                if prog.slug == "ba"
+                else ""
+            )
             console.print(
                 f"Opening a browser — log in to [bold]{prog.name}[/] (password, captcha, "
-                "SMS code). Keep the window open; it captures your session automatically."
+                f"SMS code).{ba_note} Keep the window open until this command confirms success."
             )
             cookies = login_via_browser(prog, headless=headless)
             account = Account.from_programme(prog, cookies=cookies)

{avios_cli-0.4.1 → avios_cli-0.4.2}/src/avios/rewards.py

@@ -89,6 +89,8 @@ class PassengerCounts(RewardModel):
     def infants_need_adults(self) -> PassengerCounts:
         if self.infants > self.adults:
             raise ValueError("infants cannot exceed adults")
+        if self.adults + self.young_adults + self.children + self.infants > 9:
+            raise ValueError("British Airways allows at most 9 travellers")
         return self
 
     def query_items(self) -> list[tuple[str, str]]:
@@ -354,6 +356,17 @@ def search_reward_calendar(session: Session, query: RewardSearchQuery) -> Reward
         "next-url": NEXT_URL,
         "referer": referer,
     }
+
+    if not session.has_custom_transport:
+        payload = _fetch_reward_rsc_via_browser(session, query)
+        try:
+            return parse_reward_rsc(payload, query)
+        except RewardSearchProtocolError:
+            # The Next.js router occasionally returns only its small shell during
+            # rapid consecutive searches. One fresh browser navigation recovers.
+            payload = _fetch_reward_rsc_via_browser(session, query)
+            return parse_reward_rsc(payload, query)
+
     try:
         payload = session.get_text(
             endpoints.REWARD_FLIGHT_RESULTS,
@@ -368,3 +381,150 @@ def search_reward_calendar(session: Session, query: RewardSearchQuery) -> Reward
             ) from exc
         raise
     return parse_reward_rsc(payload, query)
+
+
+def _playwright_cookies(session: Session) -> list[dict[str, Any]]:
+    """Return only app-session cookies safe to seed into the Chrome profile.
+
+    Akamai cookies are bound to browser state and are refreshed by Chrome. Replaying
+    stored ``_abck``/``bm_*`` values over the profile's current jar triggers a 403.
+    """
+    allowed = {
+        "name",
+        "value",
+        "domain",
+        "path",
+        "expires",
+        "httpOnly",
+        "secure",
+        "sameSite",
+        "partitionKey",
+    }
+    normalised: list[dict[str, Any]] = []
+    for stored in session.browser_cookies():
+        name = str(stored.get("name", ""))
+        if name != "__session" and not name.startswith("appSession"):
+            continue
+        cookie = {key: value for key, value in stored.items() if key in allowed}
+        if not cookie.get("name") or not cookie.get("value") or not cookie.get("domain"):
+            continue
+        cookie.setdefault("path", "/")
+        normalised.append(cookie)
+    return normalised
+
+
+def _fetch_reward_rsc_via_browser(
+    session: Session,
+    query: RewardSearchQuery,
+    *,
+    playwright_factory: Any = None,
+    search_driver: Any = None,
+) -> str:
+    """Drive BA's real search form and capture its RSC response through Chrome."""
+    from avios.auth import LoginError, _import_sync_playwright, _open_login_context
+
+    factory = playwright_factory or _import_sync_playwright()
+    driver = search_driver or _drive_reward_search
+    profile_dir = str(session.settings.config_dir / "chrome-profile" / "ba")
+
+    try:
+        with factory() as pw:
+            ctx = _open_login_context(
+                pw,
+                headless=False,
+                user_data_dir=profile_dir,
+                user_agent=session.settings.user_agent,
+                background=True,
+            )
+            try:
+                cookies = _playwright_cookies(session)
+                profile_cookie_names = {str(cookie.get("name", "")) for cookie in ctx.cookies()}
+                profile_has_reward_session = "__session" in profile_cookie_names or any(
+                    name.startswith("appSession") for name in profile_cookie_names
+                )
+                if cookies and not profile_has_reward_session:
+                    ctx.add_cookies(cookies)
+                page = ctx.new_page()
+                body = driver(page, session.base_url, query)
+            finally:
+                ctx.close()
+    except LoginError as exc:
+        raise RewardSearchAccessError(str(exc)) from exc
+    except RewardSearchAccessError:
+        raise
+    except Exception as exc:
+        raise RewardSearchAccessError(
+            "Chrome could not fetch British Airways reward flights. "
+            "Run `avios login ba` again, then retry."
+        ) from exc
+
+    if not isinstance(body, str):
+        raise RewardSearchProtocolError("Chrome returned a non-text reward-flight response")
+    return body
+
+
+def _select_airport(page: Any, field: str, code: str) -> None:
+    airport = page.locator(f'input[name="{field}"]')
+    if airport.input_value().rstrip().endswith(f"({code})"):
+        return
+    airport.fill(code)
+    page.get_by_test_id(f"{field}-{code}-airport-option").click(timeout=20_000)
+
+
+def _set_passengers(page: Any, passengers: PassengerCounts) -> None:
+    increments = {
+        "Adults": passengers.adults - 1,
+        "Young Adults": passengers.young_adults,
+        "Children": passengers.children,
+        "Infants": passengers.infants,
+    }
+    if not any(increments.values()):
+        return
+    selector = page.get_by_test_id("passenger number select")
+    selector.click()
+    for label, count in increments.items():
+        for _ in range(count):
+            page.get_by_test_id(f"{label}-plus").click()
+    selector.click()
+
+
+def _drive_reward_search(page: Any, base_url: str, query: RewardSearchQuery) -> str:
+    """Use the site's form so Next.js and Akamai generate valid request state."""
+    from avios.auth import BA_REWARD_SEARCH_PATH
+
+    landing = page.goto(
+        f"{base_url}{BA_REWARD_SEARCH_PATH}",
+        wait_until="domcontentloaded",
+        timeout=60_000,
+    )
+    if landing is not None and landing.status == 403:
+        raise RewardSearchAccessError(
+            "British Airways rejected the Chrome reward-search session. Run `avios login ba` again."
+        )
+    if "accounts.britishairways.com" in page.url:
+        raise RewardSearchAccessError(
+            "British Airways reward-flight login is incomplete. Run `avios login ba` "
+            "again and complete the second BA prompt."
+        )
+    page.wait_for_timeout(1_500)
+    page.get_by_role("tab", name="One Way").click()
+    _select_airport(page, "origin", query.origin)
+    _select_airport(page, "destination", query.destination)
+    _set_passengers(page, query.passengers)
+
+    with page.expect_response(
+        lambda response: (
+            endpoints.REWARD_FLIGHT_RESULTS in response.url and response.request.method == "GET"
+        ),
+        timeout=60_000,
+    ) as response_info:
+        page.get_by_role("button", name="Search", exact=True).click()
+    response = response_info.value
+    body = str(response.text())
+    if response.status in (401, 403):
+        raise RewardSearchAccessError(
+            "British Airways rejected the Chrome reward-search session. Run `avios login ba` again."
+        )
+    if response.status >= 400:
+        raise RewardSearchError(f"British Airways reward search returned HTTP {response.status}")
+    return body

{avios_cli-0.4.1 → avios_cli-0.4.2}/src/avios/session.py

@@ -2,8 +2,9 @@
 
 avios.com authenticates its internal JSON endpoints with a browser session cookie
 (no bearer token, no request signing). This module stores that cookie jar and
-builds pre-authenticated :class:`httpx.Client` instances. Acquiring the cookie in
-the first place (browser-assisted login) lives in :mod:`avios.auth`.
+builds pre-authenticated :class:`httpx.Client` instances. BA reward search is the
+exception: its Akamai-protected web flow uses Chrome directly. Acquiring cookies
+in the first place (browser-assisted login) lives in :mod:`avios.auth`.
 """
 
 from __future__ import annotations
@@ -100,6 +101,16 @@ class Session:
         cookies = self._cookies if self._cookies is not None else self.load_cookies()
         return cookie_header_from(cookies)
 
+    def browser_cookies(self) -> list[dict[str, Any]]:
+        """Return stored structured cookies suitable for seeding a browser context."""
+        cookies = self._cookies if self._cookies is not None else self.load_cookies()
+        return [dict(cookie) for cookie in cookies]
+
+    @property
+    def has_custom_transport(self) -> bool:
+        """Whether requests are routed through an injected transport (normally tests)."""
+        return self._transport is not None
+
     def is_authenticated(self) -> bool:
         return bool(self.cookie_header())
 

{avios_cli-0.4.1 → avios_cli-0.4.2}/tests/test_auth.py

@@ -126,13 +126,18 @@ class _FakeRequest:
 class _FakePage:
     def __init__(self) -> None:
         self.visited: list[str] = []
+        self.url = ""
 
     def goto(self, url: str, **kwargs: object) -> None:
         self.visited.append(url)
+        self.url = url
 
     def wait_for_timeout(self, ms: int) -> None:
         pass
 
+    def title(self) -> str:
+        return "Search Reward Flights"
+
 
 class _FakeContext:
     def __init__(self, ok_after: int, cookies: list[dict[str, str]]) -> None:
@@ -203,6 +208,24 @@ def test_login_captures_only_after_authenticated(settings: Settings) -> None:
     assert ctx.page.visited[-1].endswith("/en-GB/spend-avios/search-reward-flights")
 
 
+def test_ba_login_waits_for_separate_reward_session(settings: Settings) -> None:
+    ctx = _FakeContext(
+        ok_after=1,
+        cookies=[{"name": "ba_session_id", "value": "x", "domain": "www.avios.com"}],
+    )
+
+    with pytest.raises(LoginError, match="reward-flight login"):
+        login_via_browser(
+            BA,
+            settings=settings,
+            timeout_ms=4_000,
+            playwright_factory=_FakeFactory(ctx),
+        )
+
+    assert ctx.page.visited[-1].endswith("/en-GB/spend-avios/search-reward-flights")
+    assert ctx.closed
+
+
 def test_login_times_out_without_returning(settings: Settings) -> None:
     ctx = _FakeContext(
         ok_after=999, cookies=[{"name": "appSession", "value": "x", "domain": "www.avios.com"}]

avios_cli-0.4.2/tests/test_rewards.py

@@ -0,0 +1,324 @@
+"""Tests for BA reward-flight RSC parsing and requests."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from avios.client import AviosClient
+from avios.config import Settings
+from avios.rewards import (
+    Cabin,
+    PassengerCounts,
+    RewardSearchAccessError,
+    RewardSearchProtocolError,
+    RewardSearchQuery,
+    RewardSearchRangeError,
+    UnsupportedProgramme,
+    _fetch_reward_rsc_via_browser,
+    _select_airport,
+    _set_passengers,
+    parse_reward_rsc,
+)
+from avios.session import Session, SessionExpired
+
+FIXTURE = Path(__file__).parent / "fixtures" / "reward_search.rsc"
+COOKIE = [{"name": "appSession", "value": "x", "domain": "www.avios.com"}]
+
+
+def query(**overrides: Any) -> RewardSearchQuery:
+    values: dict[str, Any] = {
+        "origin": "lon",
+        "destination": "abz",
+        "month": "2099-11",
+    }
+    values.update(overrides)
+    return RewardSearchQuery(**values)
+
+
+def test_query_normalises_and_validates() -> None:
+    result = query(
+        passengers=PassengerCounts(adults=2, children=1),
+        cabins=(Cabin.ECONOMY, Cabin.BUSINESS, Cabin.ECONOMY),
+    )
+    assert result.origin == "LON"
+    assert result.destination == "ABZ"
+    assert result.cabins == (Cabin.ECONOMY, Cabin.BUSINESS)
+
+    with pytest.raises(ValidationError):
+        query(origin="London")
+    with pytest.raises(ValidationError):
+        query(destination="LON")
+    with pytest.raises(ValidationError):
+        query(month="2020-01")
+    with pytest.raises(ValidationError):
+        query(passengers=PassengerCounts(adults=1, infants=2))
+    with pytest.raises(ValidationError, match="at most 9"):
+        query(passengers=PassengerCounts(adults=9, children=1))
+
+
+def test_parse_realistic_rsc_without_fixed_record_position() -> None:
+    result = parse_reward_rsc(FIXTURE.read_text(), query())
+    assert result.origin_city_name == "London"
+    assert result.destination_city_name == "Aberdeen"
+    assert len(result.days) == 2
+
+    day = result.day("2099-11-05")
+    assert day.availability_level == 2
+    assert len(day.flights) == 2
+    assert day.flights[0].marketing.flight_number == "1300"
+    assert day.flights[0].seats_for(Cabin.BUSINESS) == 9
+    assert day.flights[0].seats_for(Cabin.ECONOMY) == 0
+    assert day.flights[1].peak is True
+
+
+def test_parser_filters_to_selected_cabins() -> None:
+    result = parse_reward_rsc(FIXTURE.read_text(), query(cabins=(Cabin.ECONOMY,)))
+    availability = result.day("2099-11-05").flights[0].availability
+    assert [item.cabin for item in availability] == ["M"]
+
+
+def test_parser_distinguishes_expiry_protocol_and_range() -> None:
+    with pytest.raises(SessionExpired):
+        parse_reward_rsc('0:{"message":"Sign in to continue"}', query())
+    with pytest.raises(RewardSearchProtocolError):
+        parse_reward_rsc('0:{"message":"unexpected"}', query())
+    with pytest.raises(RewardSearchRangeError):
+        parse_reward_rsc(FIXTURE.read_text(), query(month="2099-12"))
+
+
+def test_client_sends_captured_rsc_contract(settings: Settings) -> None:
+    captured: list[httpx.Request] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured.append(request)
+        return httpx.Response(
+            200,
+            text=FIXTURE.read_text(),
+            headers={"content-type": "text/x-component"},
+        )
+
+    session = Session(
+        settings,
+        opco="BAEC",
+        base_url="https://www.avios.com",
+        cookies=COOKIE,
+        transport=httpx.MockTransport(handler),
+    )
+    result = AviosClient(session).search_reward_calendar(query())
+
+    assert result.month == "2099-11"
+    request = captured[0]
+    assert request.url.path == "/en-GB/spend-avios/search-reward-flights/results"
+    params = request.url.params.multi_items()
+    assert ("originAirport", "LON") in params
+    assert ("destinationAirport", "ABZ") in params
+    assert ("month", "11") in params
+    assert [value for key, value in params if key == "cabin"] == [
+        "Economy",
+        "Premium Economy",
+        "Business",
+        "First",
+    ]
+    assert request.headers["rsc"] == "1"
+    assert request.headers["next-url"] == "/en-GB/BA/spend-avios/search-reward-flights"
+    assert "next-router-state-tree" in request.headers
+    assert "_rsc" in request.url.params
+
+
+def test_non_ba_session_is_rejected_before_network(settings: Settings) -> None:
+    session = Session(settings, opco="IBP", cookies=COOKIE)
+    with pytest.raises(UnsupportedProgramme):
+        AviosClient(session).search_reward_calendar(query())
+
+
+def test_flight_search_403_has_actionable_login_error(settings: Settings) -> None:
+    session = Session(
+        settings,
+        opco="BAEC",
+        cookies=COOKIE,
+        transport=httpx.MockTransport(lambda request: httpx.Response(403, request=request)),
+    )
+    with pytest.raises(RewardSearchAccessError, match="avios login ba"):
+        AviosClient(session).search_reward_calendar(query())
+
+
+class _BrowserResponse:
+    status = 200
+
+
+class _BrowserPage:
+    url = "https://www.avios.com/en-GB/spend-avios/search-reward-flights"
+
+    def __init__(self) -> None:
+        self.fetch_args: dict[str, Any] = {}
+
+    def goto(self, url: str, **kwargs: object) -> _BrowserResponse:
+        return _BrowserResponse()
+
+    def wait_for_timeout(self, milliseconds: int) -> None:
+        pass
+
+    def evaluate(self, expression: str, arg: dict[str, Any]) -> dict[str, Any]:
+        self.fetch_args = arg
+        return {
+            "status": 200,
+            "url": arg["url"],
+            "body": FIXTURE.read_text(),
+        }
+
+
+class _BrowserContext:
+    def __init__(self) -> None:
+        self.page = _BrowserPage()
+        self.seeded_cookies: list[dict[str, Any]] = []
+        self.closed = False
+
+    def add_cookies(self, cookies: list[dict[str, Any]]) -> None:
+        self.seeded_cookies = cookies
+
+    def cookies(self) -> list[dict[str, Any]]:
+        return []
+
+    def new_page(self) -> _BrowserPage:
+        return self.page
+
+    def close(self) -> None:
+        self.closed = True
+
+
+class _BrowserChromium:
+    def __init__(self, ctx: _BrowserContext) -> None:
+        self.ctx = ctx
+
+    def launch_persistent_context(self, path: str, **kwargs: object) -> _BrowserContext:
+        return self.ctx
+
+
+class _BrowserPlaywright:
+    def __init__(self, ctx: _BrowserContext) -> None:
+        self.chromium = _BrowserChromium(ctx)
+
+
+class _BrowserFactory:
+    def __init__(self, ctx: _BrowserContext) -> None:
+        self.playwright = _BrowserPlaywright(ctx)
+
+    def __call__(self) -> _BrowserFactory:
+        return self
+
+    def __enter__(self) -> _BrowserPlaywright:
+        return self.playwright
+
+    def __exit__(self, *args: object) -> bool:
+        return False
+
+
+def test_browser_fetch_seeds_cookies_and_returns_rsc(settings: Settings) -> None:
+    ctx = _BrowserContext()
+    captured: list[tuple[str, RewardSearchQuery]] = []
+    session = Session(
+        settings,
+        opco="BAEC",
+        base_url="https://www.avios.com",
+        cookies=COOKIE,
+    )
+
+    def driver(page: object, base_url: str, reward_query: RewardSearchQuery) -> str:
+        captured.append((base_url, reward_query))
+        return FIXTURE.read_text()
+
+    payload = _fetch_reward_rsc_via_browser(
+        session,
+        query(),
+        playwright_factory=_BrowserFactory(ctx),
+        search_driver=driver,
+    )
+
+    assert payload == FIXTURE.read_text()
+    assert ctx.seeded_cookies == [
+        {"name": "appSession", "value": "x", "domain": "www.avios.com", "path": "/"}
+    ]
+    assert captured[0][0] == "https://www.avios.com"
+    assert captured[0][1].origin == "LON"
+    assert ctx.closed
+
+
+def test_browser_search_retries_one_nextjs_shell(
+    settings: Settings,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    payloads = iter(['0:{"message":"router shell"}', FIXTURE.read_text()])
+    calls = 0
+
+    def fetch(session: Session, reward_query: RewardSearchQuery) -> str:
+        nonlocal calls
+        calls += 1
+        return next(payloads)
+
+    monkeypatch.setattr("avios.rewards._fetch_reward_rsc_via_browser", fetch)
+    session = Session(settings, opco="BAEC", base_url="https://www.avios.com", cookies=COOKIE)
+
+    result = AviosClient(session).search_reward_calendar(query())
+
+    assert result.month == "2099-11"
+    assert calls == 2
+
+
+class _ClickTarget:
+    def __init__(self) -> None:
+        self.clicks = 0
+
+    def click(self, **kwargs: object) -> None:
+        self.clicks += 1
+
+
+class _AirportInput:
+    def __init__(self, value: str) -> None:
+        self.value = value
+        self.fills: list[str] = []
+
+    def input_value(self) -> str:
+        return self.value
+
+    def fill(self, value: str) -> None:
+        self.fills.append(value)
+        self.value = value
+
+
+class _FormPage:
+    def __init__(self, airport_value: str) -> None:
+        self.airport = _AirportInput(airport_value)
+        self.targets: dict[str, _ClickTarget] = {}
+
+    def locator(self, selector: str) -> _AirportInput:
+        return self.airport
+
+    def get_by_test_id(self, test_id: str) -> _ClickTarget:
+        return self.targets.setdefault(test_id, _ClickTarget())
+
+
+def test_airport_selection_preserves_matching_default() -> None:
+    page = _FormPage("London All Airports (LON)")
+
+    _select_airport(page, "origin", "LON")
+
+    assert page.airport.fills == []
+    assert page.targets == {}
+
+
+def test_airport_and_passenger_controls_drive_site_test_ids() -> None:
+    page = _FormPage("")
+
+    _select_airport(page, "destination", "ABZ")
+    _set_passengers(page, PassengerCounts(adults=2, children=1))
+
+    assert page.airport.fills == ["ABZ"]
+    assert page.targets["destination-ABZ-airport-option"].clicks == 1
+    assert page.targets["passenger number select"].clicks == 2
+    assert page.targets["Adults-plus"].clicks == 1
+    assert page.targets["Children-plus"].clicks == 1

{avios_cli-0.4.1 → avios_cli-0.4.2}/tests/test_session.py

@@ -21,6 +21,8 @@ def test_save_and_load_cookies_round_trip(settings: Settings) -> None:
     session = _session(settings)
     session.save_cookies(AVIOS_COOKIE)
     assert session.load_cookies() == AVIOS_COOKIE
+    assert session.browser_cookies() == AVIOS_COOKIE
+    assert session.has_custom_transport is False
 
 
 def test_state_file_is_private(settings: Settings) -> None:

avios_cli-0.4.1/tests/test_rewards.py

@@ -1,142 +0,0 @@
-"""Tests for BA reward-flight RSC parsing and requests."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-import httpx
-import pytest
-from pydantic import ValidationError
-
-from avios.client import AviosClient
-from avios.config import Settings
-from avios.rewards import (
-    Cabin,
-    PassengerCounts,
-    RewardSearchAccessError,
-    RewardSearchProtocolError,
-    RewardSearchQuery,
-    RewardSearchRangeError,
-    UnsupportedProgramme,
-    parse_reward_rsc,
-)
-from avios.session import Session, SessionExpired
-
-FIXTURE = Path(__file__).parent / "fixtures" / "reward_search.rsc"
-COOKIE = [{"name": "appSession", "value": "x", "domain": "www.avios.com"}]
-
-
-def query(**overrides: Any) -> RewardSearchQuery:
-    values: dict[str, Any] = {
-        "origin": "lon",
-        "destination": "abz",
-        "month": "2099-11",
-    }
-    values.update(overrides)
-    return RewardSearchQuery(**values)
-
-
-def test_query_normalises_and_validates() -> None:
-    result = query(
-        passengers=PassengerCounts(adults=2, children=1),
-        cabins=(Cabin.ECONOMY, Cabin.BUSINESS, Cabin.ECONOMY),
-    )
-    assert result.origin == "LON"
-    assert result.destination == "ABZ"
-    assert result.cabins == (Cabin.ECONOMY, Cabin.BUSINESS)
-
-    with pytest.raises(ValidationError):
-        query(origin="London")
-    with pytest.raises(ValidationError):
-        query(destination="LON")
-    with pytest.raises(ValidationError):
-        query(month="2020-01")
-    with pytest.raises(ValidationError):
-        query(passengers=PassengerCounts(adults=1, infants=2))
-
-
-def test_parse_realistic_rsc_without_fixed_record_position() -> None:
-    result = parse_reward_rsc(FIXTURE.read_text(), query())
-    assert result.origin_city_name == "London"
-    assert result.destination_city_name == "Aberdeen"
-    assert len(result.days) == 2
-
-    day = result.day("2099-11-05")
-    assert day.availability_level == 2
-    assert len(day.flights) == 2
-    assert day.flights[0].marketing.flight_number == "1300"
-    assert day.flights[0].seats_for(Cabin.BUSINESS) == 9
-    assert day.flights[0].seats_for(Cabin.ECONOMY) == 0
-    assert day.flights[1].peak is True
-
-
-def test_parser_filters_to_selected_cabins() -> None:
-    result = parse_reward_rsc(FIXTURE.read_text(), query(cabins=(Cabin.ECONOMY,)))
-    availability = result.day("2099-11-05").flights[0].availability
-    assert [item.cabin for item in availability] == ["M"]
-
-
-def test_parser_distinguishes_expiry_protocol_and_range() -> None:
-    with pytest.raises(SessionExpired):
-        parse_reward_rsc('0:{"message":"Sign in to continue"}', query())
-    with pytest.raises(RewardSearchProtocolError):
-        parse_reward_rsc('0:{"message":"unexpected"}', query())
-    with pytest.raises(RewardSearchRangeError):
-        parse_reward_rsc(FIXTURE.read_text(), query(month="2099-12"))
-
-
-def test_client_sends_captured_rsc_contract(settings: Settings) -> None:
-    captured: list[httpx.Request] = []
-
-    def handler(request: httpx.Request) -> httpx.Response:
-        captured.append(request)
-        return httpx.Response(
-            200,
-            text=FIXTURE.read_text(),
-            headers={"content-type": "text/x-component"},
-        )
-
-    session = Session(
-        settings,
-        opco="BAEC",
-        base_url="https://www.avios.com",
-        cookies=COOKIE,
-        transport=httpx.MockTransport(handler),
-    )
-    result = AviosClient(session).search_reward_calendar(query())
-
-    assert result.month == "2099-11"
-    request = captured[0]
-    assert request.url.path == "/en-GB/spend-avios/search-reward-flights/results"
-    params = request.url.params.multi_items()
-    assert ("originAirport", "LON") in params
-    assert ("destinationAirport", "ABZ") in params
-    assert ("month", "11") in params
-    assert [value for key, value in params if key == "cabin"] == [
-        "Economy",
-        "Premium Economy",
-        "Business",
-        "First",
-    ]
-    assert request.headers["rsc"] == "1"
-    assert request.headers["next-url"] == "/en-GB/BA/spend-avios/search-reward-flights"
-    assert "next-router-state-tree" in request.headers
-    assert "_rsc" in request.url.params
-
-
-def test_non_ba_session_is_rejected_before_network(settings: Settings) -> None:
-    session = Session(settings, opco="IBP", cookies=COOKIE)
-    with pytest.raises(UnsupportedProgramme):
-        AviosClient(session).search_reward_calendar(query())
-
-
-def test_flight_search_403_has_actionable_login_error(settings: Settings) -> None:
-    session = Session(
-        settings,
-        opco="BAEC",
-        cookies=COOKIE,
-        transport=httpx.MockTransport(lambda request: httpx.Response(403, request=request)),
-    )
-    with pytest.raises(RewardSearchAccessError, match="avios login ba"):
-        AviosClient(session).search_reward_calendar(query())