fix: surface DVhub feed-in tariff update failures (#1357)

* fix: surface DVhub feed-in tariff update failures

* test: annotate DVhub sample records for mypy

* fix: require real feed-in tariff coverage in GENETIC0

* test: satisfy GENETIC0 tariff coverage checks

* test: patch DVhub storage method on its class

tests/test_feedintariffdvhubonline.py

@@ -1,16 +1,20 @@
 """Tests for the dvhub.online feed-in tariff provider."""
 
 import os
-from unittest.mock import MagicMock, patch
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
+import requests
 
+from akkudoktoreos.core.coreabc import get_ems
 from akkudoktoreos.prediction.feedintariffdvhubonline import (
     FeedInTariffDvhubOnline,
     FeedInTariffDvhubOnlineCommonSettings,
 )
+from akkudoktoreos.utils.datetimeutil import to_datetime
 
-SAMPLE = {
+SAMPLE: dict[str, list[dict[str, Any]]] = {
     "data": [
         {"ts": "2026-07-19T12:00:00.000Z", "price": 42.5},   # EUR/MWh
         {"ts": "2026-07-19T12:15:00.000Z", "price": -5.69},  # negative slot
@@ -23,9 +27,11 @@ SAMPLE = {
 @pytest.fixture
 def provider(config_eos):
     config_eos.merge_settings_from_dict(
-        {"feedintariff": {"provider": "FeedInTariffDvhubOnline"}}
+        {"feedintariff": {"provider": "FeedInTariffDvhubOnline"}, "prediction": {"hours": 2}}
     )
+    get_ems().set_start_datetime(to_datetime("2026-07-19T12:00:00+00:00"))
     provider = FeedInTariffDvhubOnline()
+    provider.highest_orig_datetime = None
     assert provider.enabled()
     provider._db_reset_state()
     return provider
@@ -61,6 +67,58 @@ class TestFeedInTariffDvhubOnline:
                     start_date="2026-07-19", end_date="2026-07-21", force_update=True
                 )
 
+    @pytest.mark.asyncio
+    async def test_update_stores_only_published_slots(self, provider, monkeypatch):
+        monkeypatch.setattr(provider, "_request_forecast", lambda **_: SAMPLE)
+
+        await provider._update_data(force_update=True)
+
+        stored = await provider.key_to_raw_series(key="feed_in_tariff_wh")
+        assert len(stored) == 2
+        assert stored.tolist() == pytest.approx([42.5 / 1_000_000, -5.69 / 1_000_000])
+        assert provider.highest_orig_datetime == to_datetime(SAMPLE["data"][1]["ts"])
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "error",
+        [requests.HTTPError("400 Bad Request"), ValueError("invalid JSON"), RuntimeError("bug")],
+    )
+    async def test_update_propagates_failure_despite_existing_history(
+        self, provider, monkeypatch, error
+    ):
+        previous = to_datetime(SAMPLE["data"][0]["ts"])
+        provider.highest_orig_datetime = previous
+
+        def fail(**kwargs):
+            raise error
+
+        monkeypatch.setattr(provider, "_request_forecast", fail)
+        with pytest.raises(type(error), match=str(error)):
+            await provider._update_data(force_update=True)
+        assert provider.highest_orig_datetime == previous
+
+    @pytest.mark.asyncio
+    async def test_update_rejects_empty_response_with_existing_history(self, provider, monkeypatch):
+        provider.highest_orig_datetime = to_datetime(SAMPLE["data"][0]["ts"])
+        monkeypatch.setattr(provider, "_request_forecast", lambda **_: {"data": []})
+
+        with pytest.raises(ValueError, match="No dvhub.online feed-in tariff data"):
+            await provider._update_data(force_update=True)
+
+    @pytest.mark.asyncio
+    async def test_update_does_not_mark_failed_storage_as_fresh(self, provider, monkeypatch):
+        previous = to_datetime(SAMPLE["data"][0]["ts"])
+        provider.highest_orig_datetime = previous
+        monkeypatch.setattr(provider, "_request_forecast", lambda **_: SAMPLE)
+        with patch.object(
+            FeedInTariffDvhubOnline,
+            "key_from_series",
+            new=AsyncMock(side_effect=RuntimeError("storage failed")),
+        ):
+            with pytest.raises(RuntimeError, match="storage failed"):
+                await provider._update_data(force_update=True)
+        assert provider.highest_orig_datetime == previous
+
 
 @pytest.mark.skipif(
     os.environ.get("EOS_DVHUB_ONLINE_LIVE") != "1",

tests/test_genetic0_tariff_coverage.py

@@ -0,0 +1,65 @@
+"""GENETIC0 must not extend a published feed-in tariff beyond real coverage."""
+
+from unittest.mock import AsyncMock, Mock, patch
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from akkudoktoreos.core.coreabc import get_ems
+from akkudoktoreos.optimization.genetic0.genetic0params import (
+    Genetic0OptimizationParameters,
+)
+from akkudoktoreos.utils.datetimeutil import to_datetime
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("published_hours", [20, 24])
+async def test_dvhub_tariff_requires_real_control_horizon(
+    config_eos, published_hours, caplog
+):
+    config_eos.merge_settings_from_dict(
+        {
+            "prediction": {"hours": 48},
+            "optimization": {"genetic0": {"horizon_hours": 24}},
+            "feedintariff": {"provider": "FeedInTariffDvhubOnline"},
+            "elecfee": {"provider": None},
+            "devices": {
+                "max_batteries": 0,
+                "max_electric_vehicles": 0,
+                "max_inverters": 0,
+                "max_home_appliances": 0,
+            },
+        }
+    )
+    start = to_datetime("2026-08-01T00:00:00+00:00")
+    get_ems().set_start_datetime(start)
+    prices = pd.Series(
+        np.arange(published_hours * 4, dtype=float) / 1_000_000,
+        index=pd.date_range(start, periods=published_hours * 4, freq="15min"),
+    )
+
+    async def read_array(**kwargs):
+        return np.full(48, 1.0)
+
+    prediction = Mock(
+        update_data=AsyncMock(),
+        key_to_array=AsyncMock(side_effect=read_array),
+        key_to_raw_series=AsyncMock(return_value=prices),
+    )
+    with patch.object(Genetic0OptimizationParameters, "prediction", prediction):
+        parameters = await Genetic0OptimizationParameters.prepare()
+
+    prediction.update_data.assert_awaited_once()
+    assert config_eos.feedintariff.provider == "FeedInTariffDvhubOnline"
+    if published_hours < 24:
+        assert parameters is None
+        assert "Missing feed-in tariff within the GENETIC0 control horizon" in caplog.text
+    else:
+        assert parameters is not None
+        tariffs = parameters.ems.feed_in_tariff_per_wh
+        assert isinstance(tariffs, list)
+        assert tariffs[:24] == pytest.approx(
+            [(4 * hour + 1.5) / 1_000_000 for hour in range(24)]
+        )
+        assert np.isnan(tariffs[24:]).all()