PolyWeather/tests/test_multi_model_sources.py

from datetime import datetime, timezone, timedelta
import time

from src.data_collection.nws_open_meteo_sources import (
    OPEN_METEO_MULTI_MODEL_ORDER,
    _parse_open_meteo_multi_model_daily,
)
from src.data_collection.forecast_source_bundle import ensure_multi_model_hourly_payload
import src.data_collection.open_meteo_cache as open_meteo_cache_module
import src.data_collection.weather_sources as weather_sources_module
from src.data_collection.weather_sources import WeatherDataCollector
from src.database.runtime_state import (
    OpenMeteoCacheRepository,
    OpenMeteoRateLimitRepository,
    RuntimeStateDB,
)


def test_multi_model_parser_exposes_open_recommended_models():
    daily = {
        "time": ["2026-04-17", "2026-04-18"],
        "temperature_2m_max_ecmwf_ifs025": [20.1, 21.1],
        "temperature_2m_max_ecmwf_aifs025_single": [20.2, 21.2],
        "temperature_2m_max_icon_eu": [20.3, 21.3],
        "temperature_2m_max_icon_d2": [20.4, None],
        "temperature_2m_max_gem_global": [19.8, 20.8],
        "temperature_2m_max_gem_regional": [21.0, 22.0],
        "temperature_2m_max_gem_hrdps_continental": [21.5, None],
    }

    dates, forecasts, metadata, model_keys = _parse_open_meteo_multi_model_daily(daily)

    assert dates == ["2026-04-17", "2026-04-18"]
    assert forecasts["2026-04-17"]["ECMWF"] == 20.1
    assert forecasts["2026-04-17"]["ECMWF AIFS"] == 20.2
    assert forecasts["2026-04-17"]["ICON-EU"] == 20.3
    assert forecasts["2026-04-17"]["ICON-D2"] == 20.4
    assert forecasts["2026-04-17"]["GDPS"] == 19.8
    assert forecasts["2026-04-17"]["RDPS"] == 21.0
    assert forecasts["2026-04-17"]["HRDPS"] == 21.5
    assert "ICON-D2" not in forecasts["2026-04-18"]
    assert metadata["ECMWF AIFS"]["provider"] == "ECMWF"
    assert metadata["HRDPS"]["resolution_km"] == 2.5
    assert model_keys["RDPS"] == "gem_regional"


def test_multi_model_parser_exposes_north_america_open_meteo_models():
    daily = {
        "time": ["2026-06-05", "2026-06-06"],
        "temperature_2m_max_gfs_global": [92.1, 91.4],
        "temperature_2m_max_ncep_hrrr_conus": [92.3, None],
        "temperature_2m_max_ncep_nbm_conus": [87.2, 88.7],
        "temperature_2m_max_ncep_nam_conus": [87.9, 91.7],
        "temperature_2m_max_ncep_gfs_graphcast025": [84.4, 86.1],
        "temperature_2m_max_ncep_aigfs025": [85.9, 88.3],
    }

    dates, forecasts, metadata, model_keys = _parse_open_meteo_multi_model_daily(daily)

    assert dates == ["2026-06-05", "2026-06-06"]
    assert forecasts["2026-06-05"]["GFS Global"] == 92.1
    assert forecasts["2026-06-05"]["HRRR"] == 92.3
    assert forecasts["2026-06-05"]["NBM"] == 87.2
    assert forecasts["2026-06-05"]["NAM"] == 87.9
    assert forecasts["2026-06-05"]["GFS GraphCast"] == 84.4
    assert forecasts["2026-06-05"]["AI-GFS"] == 85.9
    assert "HRRR" not in forecasts["2026-06-06"]
    assert metadata["HRRR"]["provider"] == "NOAA"
    assert metadata["NBM"]["tier"] == "regional_north_america"
    assert model_keys["AI-GFS"] == "ncep_aigfs025"


def test_multi_model_order_includes_legacy_and_new_sources():
    assert "ecmwf_ifs025" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "ecmwf_aifs025_single" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "gfs_seamless" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "icon_seamless" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "icon_eu" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "icon_d2" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "gem_seamless" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "gem_global" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "gem_regional" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "gem_hrdps_continental" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "gfs_global" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "ncep_hrrr_conus" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "ncep_nbm_conus" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "ncep_nam_conus" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "ncep_gfs_graphcast025" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "ncep_aigfs025" in OPEN_METEO_MULTI_MODEL_ORDER
    assert "jma_seamless" in OPEN_METEO_MULTI_MODEL_ORDER


def test_multi_model_default_cache_version_refreshes_noaa_model_set(monkeypatch):
    monkeypatch.delenv("OPEN_METEO_MULTI_MODEL_CACHE_VERSION", raising=False)

    collector = WeatherDataCollector({})

    assert collector.multi_model_cache_version == "v5"


def test_madis_patch_uses_city_display_unit_for_us(monkeypatch):
    collector = WeatherDataCollector({})
    emitted = []
    stored = []

    monkeypatch.setattr(
        collector,
        "fetch_madis_hfmetar",
        lambda: [
            {
                "icao": "KHOU",
                "temp_c": 19.4,
                "obs_time": "2026-05-27T17:00:00+00:00",
                "wind_kt": 8.0,
            }
        ],
    )
    monkeypatch.setattr(
        collector,
        "_emit_temperature_patch_if_changed",
        lambda city, temp, obs_time=None, **kwargs: emitted.append(
            {
                "city": city,
                "temp": temp,
                "obs_time": obs_time,
                **kwargs,
            }
        ),
    )

    class FakeDBManager:
        def append_airport_obs(self, **kwargs):
            stored.append(kwargs)

    monkeypatch.setattr(
        "src.data_collection.weather_sources.DBManager",
        lambda: FakeDBManager(),
    )

    results = {}
    collector._attach_madis_hfmetar_data(
        results,
        "houston",
        use_fahrenheit=True,
    )

    assert results["madis_hfmetar_current"]["temp"] == 66.9
    assert results["madis_hfmetar_current"]["temp_c"] == 19.4
    assert emitted[0]["temp"] == 66.9
    assert emitted[0]["extra"]["temp_c"] == 19.4
    assert emitted[0]["extra"]["unit"] == "fahrenheit"
    assert stored[0]["temp_c"] == 19.4


def test_fetch_all_sources_prioritizes_multi_model_before_forecast(monkeypatch, tmp_path):
    monkeypatch.setenv("OPEN_METEO_DISK_CACHE_PATH", str(tmp_path / "om-cache.json"))
    collector = WeatherDataCollector({})
    calls = []

    monkeypatch.setattr(collector, "_log_temperature_unit", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_settlement_sources", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_supports_aviationweather", lambda city: False)
    monkeypatch.setattr(collector, "_attach_turkish_mgm_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_korean_amos_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_china_amsc_awos_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_madis_hfmetar_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_singapore_mss_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_china_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_japan_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_fmi_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_knmi_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_hko_obs_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_cwa_settlement_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_global_nearby_cluster", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "fetch_ensemble", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "fetch_nws", lambda *args, **kwargs: None)

    def fake_multi_model(*args, **kwargs):
        calls.append("multi_model")
        return {"forecasts": {"ECMWF": 24.0, "GFS": 25.0}}

    def fake_open_meteo(*args, **kwargs):
        calls.append("open_meteo")
        return {"utc_offset": 10800, "daily": {"temperature_2m_max": [24]}}

    monkeypatch.setattr(collector, "fetch_multi_model", fake_multi_model)
    monkeypatch.setattr(collector, "fetch_from_open_meteo", fake_open_meteo)

    result = collector.fetch_all_sources(
        "ankara",
        lat=40.1281,
        lon=32.9951,
        include_ensemble=False,
        include_nearby=False,
        include_taf=False,
        include_mgm=False,
    )

    assert calls[:2] == ["multi_model", "open_meteo"]
    assert result["multi_model"]["forecasts"]["ECMWF"] == 24.0


def test_fetch_all_sources_delegates_non_hf_forecast_bundle(monkeypatch, tmp_path):
    monkeypatch.setenv("OPEN_METEO_DISK_CACHE_PATH", str(tmp_path / "om-cache.json"))
    collector = WeatherDataCollector({})
    calls = []

    monkeypatch.setattr(collector, "_log_temperature_unit", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_evict_city_caches", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_settlement_sources", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_supports_aviationweather", lambda city: False)
    monkeypatch.setattr(collector, "_attach_turkish_mgm_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_korean_amos_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_china_amsc_awos_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_madis_hfmetar_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_singapore_mss_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_israel_ims_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_saudi_ncm_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_paris_aeroweb_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_china_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_japan_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_fmi_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_knmi_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_cowin_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_hko_obs_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_cwa_settlement_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_global_nearby_cluster", lambda *args, **kwargs: None)

    def fake_forecast_bundle(collector_arg, **kwargs):
        calls.append({"collector": collector_arg, **kwargs})
        return {
            "open-meteo": {
                "utc_offset": 10800,
                "daily": {"temperature_2m_max": [24.0]},
            },
            "multi_model": {"forecasts": {"ECMWF": 24.5}},
        }

    monkeypatch.setattr(
        weather_sources_module,
        "fetch_open_meteo_forecast_bundle",
        fake_forecast_bundle,
    )

    result = collector.fetch_all_sources(
        "ankara",
        lat=40.1281,
        lon=32.9951,
        force_refresh_observations_only=True,
        include_ensemble=False,
        include_nearby=False,
        include_taf=False,
        include_mgm=False,
    )

    assert calls == [
        {
            "collector": collector,
            "city": "ankara",
            "lat": 40.1281,
            "lon": 32.9951,
            "use_fahrenheit": False,
            "include_multi_model": True,
            "cache_only": True,
        }
    ]
    assert result["open-meteo"]["utc_offset"] == 10800
    assert result["multi_model"]["forecasts"]["ECMWF"] == 24.5


def test_open_meteo_cache_only_reads_multi_model_without_forecast_cache():
    from src.data_collection.forecast_source_bundle import fetch_open_meteo_forecast_bundle

    today = datetime.now(timezone.utc).date().isoformat()

    class DummyLock:
        def __enter__(self):
            return None

        def __exit__(self, *_args):
            return False

    class FakeCollector:
        multi_model_cache_version = "v5"
        _open_meteo_cache = {}
        _open_meteo_cache_lock = DummyLock()
        _multi_model_cache_lock = DummyLock()
        _multi_model_cache = {
            "48.9694:2.4414:paris:c:v5": {
                "data": {
                    "hourly_times": [f"{today}T15:00"],
                    "hourly_forecasts": {"ECMWF": [24.5]},
                    "forecasts": {"ECMWF": 27.0},
                }
            }
        }

        def _maybe_reload_open_meteo_disk_cache(self):
            return None

    result = fetch_open_meteo_forecast_bundle(
        FakeCollector(),
        city="paris",
        lat=48.9694,
        lon=2.4414,
        use_fahrenheit=False,
        include_multi_model=True,
        cache_only=True,
    )

    assert result["multi_model"]["hourly_forecasts"]["ECMWF"] == [24.5]


def test_ensure_multi_model_hourly_payload_fetches_missing_hourly_outside_analysis_layer():
    calls = []

    class FakeCollector:
        def fetch_multi_model(self, lat, lon, *, city, use_fahrenheit):
            calls.append(
                {
                    "lat": lat,
                    "lon": lon,
                    "city": city,
                    "use_fahrenheit": use_fahrenheit,
                }
            )
            return {
                "hourly_times": ["2026-06-14T10:00"],
                "hourly_forecasts": {"ECMWF": [24.1]},
                "forecasts": {"ECMWF": 26.0},
            }

    result = ensure_multi_model_hourly_payload(
        FakeCollector(),
        {"forecasts": {"GFS": 25.0}},
        city="ankara",
        lat=40.1281,
        lon=32.9951,
        use_fahrenheit=False,
    )

    assert calls == [
        {
            "lat": 40.1281,
            "lon": 32.9951,
            "city": "ankara",
            "use_fahrenheit": False,
        }
    ]
    assert result["forecasts"] == {"ECMWF": 26.0}
    assert result["hourly_times"] == ["2026-06-14T10:00"]
    assert result["hourly_forecasts"]["ECMWF"] == [24.1]


def test_ensure_multi_model_hourly_payload_reuses_existing_hourly():
    class FakeCollector:
        def fetch_multi_model(self, *_args, **_kwargs):
            raise AssertionError("existing hourly payload should not fetch again")

    result = ensure_multi_model_hourly_payload(
        FakeCollector(),
        {
            "forecasts": {"GFS": 25.0},
            "hourly_times": ["2026-06-14T10:00"],
            "hourly_forecasts": {"GFS": [24.0]},
        },
        city="ankara",
        lat=40.1281,
        lon=32.9951,
        use_fahrenheit=False,
    )

    assert result["forecasts"]["GFS"] == 25.0
    assert result["hourly_forecasts"]["GFS"] == [24.0]


def test_force_refresh_preserves_open_meteo_model_caches_by_default(monkeypatch, tmp_path):
    monkeypatch.setenv("OPEN_METEO_DISK_CACHE_PATH", str(tmp_path / "om-cache.json"))
    collector = WeatherDataCollector({})
    captured = {}

    def fake_evict(*args, **kwargs):
        captured["keep_model_caches"] = kwargs.get("keep_model_caches")

    monkeypatch.setattr(collector, "_evict_city_caches", fake_evict)
    monkeypatch.setattr(collector, "_log_temperature_unit", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_settlement_sources", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_supports_aviationweather", lambda city: False)
    monkeypatch.setattr(collector, "fetch_multi_model", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "fetch_from_open_meteo", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_nws_and_models", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_turkish_mgm_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_korean_amos_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_china_amsc_awos_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_madis_hfmetar_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_singapore_mss_data", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_china_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_japan_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_fmi_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_knmi_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_hko_obs_official_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_cwa_settlement_nearby", lambda *args, **kwargs: None)
    monkeypatch.setattr(collector, "_attach_global_nearby_cluster", lambda *args, **kwargs: None)

    collector.fetch_all_sources(
        "ankara",
        lat=40.1281,
        lon=32.9951,
        force_refresh=True,
        include_ensemble=False,
        include_nearby=False,
        include_taf=False,
        include_mgm=False,
    )

    assert captured["keep_model_caches"] is True


def test_persisted_open_meteo_cooldown_skips_outbound_request(monkeypatch, tmp_path):
    monkeypatch.setenv("POLYWEATHER_STATE_STORAGE_MODE", "sqlite")
    monkeypatch.setenv("POLYWEATHER_DB_PATH", str(tmp_path / "polyweather.db"))
    monkeypatch.setenv("OPEN_METEO_DISK_CACHE_PATH", str(tmp_path / "om-cache.json"))
    db = RuntimeStateDB(str(tmp_path / "polyweather.db"))
    cache_repo = OpenMeteoCacheRepository(db)
    rate_repo = OpenMeteoRateLimitRepository(db)
    monkeypatch.setattr(open_meteo_cache_module, "_open_meteo_cache_repo", cache_repo)
    monkeypatch.setattr(open_meteo_cache_module, "_open_meteo_rate_limit_repo", rate_repo)

    collector = WeatherDataCollector({})
    cache_key = (
        f"{round(float(40.1281), 4)}:{round(float(32.9951), 4)}:ankara:"
        f"c:{collector.multi_model_cache_version}"
    )
    cache_repo.replace_payload(
        {
            "multi_model": {
                cache_key: {
                    "t": 9999999998.0,
                    "data": {"forecasts": {"ECMWF": 26.0}},
                }
            }
        },
        max_age=86400,
    )
    collector._load_open_meteo_disk_cache()
    rate_repo.set_until(9999999999.0, reason="test_429")

    def fail_http(*args, **kwargs):
        raise AssertionError("Open-Meteo HTTP request should be skipped during persisted cooldown")

    monkeypatch.setattr(collector, "_http_get", fail_http)

    result = collector.fetch_multi_model(40.1281, 32.9951, city="ankara")

    assert result is not None  # cooldown returns cached data


def test_fetch_multi_model_ignores_cache_when_dates_are_stale(monkeypatch, tmp_path):
    monkeypatch.setenv("OPEN_METEO_DISK_CACHE_PATH", str(tmp_path / "om-cache.json"))
    collector = WeatherDataCollector({})
    today = datetime.now(timezone.utc).date()
    old_dates = [
        (today - timedelta(days=11)).isoformat(),
        (today - timedelta(days=10)).isoformat(),
    ]
    fresh_dates = [today.isoformat(), (today + timedelta(days=1)).isoformat()]
    cache_key = (
        f"{round(float(48.9694), 4)}:{round(float(2.4414), 4)}:paris:"
        f"c:{collector.multi_model_cache_version}"
    )
    collector._multi_model_cache[cache_key] = {
        "t": time.time(),
        "data": {
            "dates": old_dates,
            "daily_forecasts": {old_dates[0]: {"ECMWF": 24.0}},
            "forecasts": {"ECMWF": 24.0},
            "hourly_times": [f"{old_dates[0]}T15:00"],
            "hourly_forecasts": {"ECMWF": [23.0]},
        },
    }
    calls = []

    class FakeResponse:
        def raise_for_status(self):
            return None

        def json(self):
            return {
                "daily": {
                    "time": fresh_dates,
                    "temperature_2m_max_ecmwf_ifs025": [39.2, 33.0],
                    "temperature_2m_max_gfs_seamless": [38.6, 32.5],
                },
                "hourly": {
                    "time": [f"{fresh_dates[0]}T15:00", f"{fresh_dates[0]}T16:00"],
                    "temperature_2m_ecmwf_ifs025": [38.8, 39.2],
                    "temperature_2m_gfs_seamless": [38.0, 38.6],
                },
            }

    monkeypatch.setattr(collector, "_wait_open_meteo_slot", lambda *_args, **_kwargs: None)
    monkeypatch.setattr(
        collector,
        "_http_get",
        lambda *args, **kwargs: calls.append((args, kwargs)) or FakeResponse(),
    )

    result = collector.fetch_multi_model(48.9694, 2.4414, city="paris")

    assert len(calls) == 1
    assert result["dates"][:2] == fresh_dates
    assert result["forecasts"]["ECMWF"] == 39.2
    assert result["forecasts"]["GFS"] == 38.6


def test_fetch_open_meteo_ignores_cache_when_dates_are_stale(monkeypatch, tmp_path):
    monkeypatch.setenv("OPEN_METEO_DISK_CACHE_PATH", str(tmp_path / "om-cache.json"))
    collector = WeatherDataCollector({})
    today = datetime.now(timezone.utc).date()
    old_dates = [
        (today - timedelta(days=11)).isoformat(),
        (today - timedelta(days=10)).isoformat(),
    ]
    fresh_dates = [today.isoformat(), (today + timedelta(days=1)).isoformat()]
    cache_key = f"{round(float(48.9694), 4)}:{round(float(2.4414), 4)}:14:c"
    collector._open_meteo_cache[cache_key] = {
        "t": time.time(),
        "data": {
            "source": "open-meteo",
            "daily": {
                "time": old_dates,
                "temperature_2m_max": [24.5, 26.6],
            },
            "hourly": {"time": [f"{old_dates[0]}T15:00"], "temperature_2m": [24.0]},
        },
    }
    calls = []

    class FakeResponse:
        def raise_for_status(self):
            return None

        def json(self):
            return {
                "current_weather": {"temperature": 32.0},
                "utc_offset_seconds": 7200,
                "timezone": "Europe/Paris",
                "daily": {
                    "time": fresh_dates,
                    "temperature_2m_max": [39.2, 33.0],
                    "sunrise": [f"{fresh_dates[0]}T05:30", f"{fresh_dates[1]}T05:31"],
                    "sunset": [f"{fresh_dates[0]}T21:55", f"{fresh_dates[1]}T21:55"],
                    "sunshine_duration": [36000, 33000],
                },
                "hourly": {
                    "time": [f"{fresh_dates[0]}T15:00", f"{fresh_dates[0]}T16:00"],
                    "temperature_2m": [38.8, 39.2],
                },
            }

    monkeypatch.setattr(collector, "_wait_open_meteo_slot", lambda *_args, **_kwargs: None)
    monkeypatch.setattr(
        collector,
        "_http_get",
        lambda *args, **kwargs: calls.append((args, kwargs)) or FakeResponse(),
    )

    result = collector.fetch_from_open_meteo(48.9694, 2.4414)

    assert len(calls) == 1
    assert result["daily"]["time"][:2] == fresh_dates
    assert result["daily"]["temperature_2m_max"][0] == 39.2


def test_multi_model_hourly_parser():
    from src.data_collection.nws_open_meteo_sources import _parse_open_meteo_multi_model_hourly

    hourly = {
        "time": ["2026-05-21T00:00", "2026-05-21T01:00"],
        "temperature_2m_ecmwf_ifs025": [15.2, 15.0],
        "temperature_2m_gfs_seamless": [14.8, None],
        "temperature_2m_icon_d2": [None, None],  # completely empty, should be ignored
    }

    times, forecasts = _parse_open_meteo_multi_model_hourly(hourly)

    assert times == ["2026-05-21T00:00", "2026-05-21T01:00"]
    assert forecasts["ECMWF"] == [15.2, 15.0]
    assert forecasts["GFS"] == [14.8, None]
    assert "ICON-D2" not in forecasts


def test_merge_multi_model_result_with_cache_hourly():
    from src.data_collection.nws_open_meteo_sources import _merge_multi_model_result_with_cache

    cached = {
        "forecasts": {"ECMWF": 20.0, "GFS": 19.5, "ICON-EU": 19.8},
        "daily_forecasts": {
            "2026-05-21": {"ECMWF": 20.0, "GFS": 19.5, "ICON-EU": 19.8}
        },
        "hourly_times": ["2026-05-21T00:00", "2026-05-21T01:00"],
        "hourly_forecasts": {
            "ECMWF": [15.2, 15.0],
            "GFS": [14.8, 14.5],
            "ICON-EU": [15.0, 14.8],
        },
    }

    fresh = {
        "forecasts": {"ECMWF": 20.2},  # Only ECMWF returned (e.g. subset refresh)
        "daily_forecasts": {
            "2026-05-21": {"ECMWF": 20.2}
        },
        "hourly_times": ["2026-05-21T01:00", "2026-05-21T02:00"],  # time shifts forward
        "hourly_forecasts": {
            "ECMWF": [15.1, 15.3],
        },
    }

    merged = _merge_multi_model_result_with_cache(cached, fresh)

    # Standard checks
    assert merged["forecasts"]["ECMWF"] == 20.2
    assert merged["forecasts"]["GFS"] == 19.5
    assert merged["forecasts"]["ICON-EU"] == 19.8

    # Hourly merge and alignment checks
    assert merged["hourly_times"] == ["2026-05-21T01:00", "2026-05-21T02:00"]
    # At T01:00, fresh has ECMWF=15.1, cached has GFS=14.5, ICON-EU=14.8
    assert merged["hourly_forecasts"]["ECMWF"] == [15.1, 15.3]
    assert merged["hourly_forecasts"]["GFS"] == [14.5, None]
    assert merged["hourly_forecasts"]["ICON-EU"] == [14.8, None]


def test_merge_multi_model_result_drops_missing_short_range_hourly_from_cache():
    from src.data_collection.nws_open_meteo_sources import _merge_multi_model_result_with_cache

    cached = {
        "forecasts": {"ECMWF": 28.0, "AROME HD": 27.0},
        "daily_forecasts": {
            "2026-06-16": {"ECMWF": 28.0, "AROME HD": 27.0}
        },
        "hourly_times": [
            "2026-06-16T00:00",
            "2026-06-16T01:00",
            "2026-06-16T02:00",
            "2026-06-16T03:00",
            "2026-06-16T04:00",
            "2026-06-16T05:00",
        ],
        "hourly_forecasts": {
            "ECMWF": [21.0, 21.5, 22.0, 22.5, 23.0, 23.5],
            "AROME HD": [25.0, 24.5, 24.0, 23.5, 23.0, 22.5],
        },
    }
    fresh = {
        "forecasts": {"ECMWF": 28.2},
        "daily_forecasts": {"2026-06-16": {"ECMWF": 28.2}},
        "hourly_times": [
            "2026-06-16T00:00",
            "2026-06-16T01:00",
            "2026-06-16T02:00",
            "2026-06-16T03:00",
            "2026-06-16T04:00",
            "2026-06-16T05:00",
            "2026-06-16T06:00",
        ],
        "hourly_forecasts": {
            "ECMWF": [21.2, 21.7, 22.2, 22.7, 23.2, 23.7, 24.0],
        },
    }

    merged = _merge_multi_model_result_with_cache(cached, fresh)

    assert merged["hourly_forecasts"]["ECMWF"] == [21.2, 21.7, 22.2, 22.7, 23.2, 23.7, 24.0]
    assert "AROME HD" not in merged["hourly_forecasts"]