refactor: tariff-pause warning-flap suppression (v1.6.3 review)

Pre-deploy review for v1.6.3 (#301 PR series) flagged duplicated
``_tariff_pause_warned = False`` calls in the daytime tariff-pause
path — once inside the EXPENSIVE branch, once after it. The review's
read was that the EXPENSIVE-branch clear was a bug; closer reading
shows both clears are inside the ``try``, so both fire only on a
successful ``get_price_level()``. The actual invariant is
``successful read ⇒ flag cleared``, regardless of which price
level came back.

Refactor pulls the clear above the price-level branch so the
invariant is local to one line. Behaviour-identical to the prior
factoring but no longer reads like a price-level bug to future
reviewers.

New ``TestTariffPauseWarningFlap`` covers the contract:
- one warning per provider outage, even across many ticks
- successful read with EXPENSIVE price clears the flag
- successful read with CHEAP price clears the flag
- a recovery + fresh outage re-arms and re-fires

Follow-up cleanups deferred to #304 (select.py orphan-removal
gap for previously-removed chargers) and #305 (dead
_auto_mode_strategy + min_pv mapper branch).

2140 / 2140 tests passing (4 new).

Author: belinea4071

coordinator/coordinator.py

@@ -2464,18 +2464,24 @@ def _determine_charging_strategy(self, power: PowerReadings, energy: Any,
         if mode == "solar_plus_cheap":
             try:
                 level = self._tariff_provider.get_price_level()
+                # A successful call means the provider is healthy — drop
+                # the one-shot ``provider error'' warning flag regardless
+                # of the returned price level. The next exception will
+                # re-arm it. Cleared *before* the branch on ``level`` so
+                # the EXPENSIVE and CHEAP paths share identical recovery
+                # semantics (#301 review pushed back on a duplicated
+                # clear that read like a price-level bug; the canonical
+                # invariant is ``successful read ⇒ no pending warning'').
+                if getattr(self, "_tariff_pause_warned", False):
+                    self._tariff_pause_warned = False
                 if level in (PriceLevel.EXPENSIVE, PriceLevel.VERY_EXPENSIVE):
                     _LOGGER.debug(
                         "Tariff pause: %s price — solar_plus_cheap "
                         "falling through to pure surplus", level.value,
                     )
                     # Falls through to self_consumption to enforce
                     # surplus-only during expensive windows.
-                    if getattr(self, "_tariff_pause_warned", False):
-                        self._tariff_pause_warned = False
                     return self._self_consumption_strategy(power, energy)
-                if getattr(self, "_tariff_pause_warned", False):
-                    self._tariff_pause_warned = False  # provider recovered
             except Exception as e:
                 # Surface once (#274/L1) — a persistently broken provider
                 # would otherwise silently keep the surplus-from-grid

tests/test_ev_deadline_tariff.py

@@ -6,6 +6,7 @@
 - the daytime tariff pause in _determine_charging_strategy
 - the deadline current-floor applied in _execute_ev_control's night branch
 """
+import logging
 from datetime import timedelta
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -358,6 +359,130 @@ def test_min_plus_solar_ignores_tariff_signal(self):
         assert strategy == "solar_only"
 
 
+class TestTariffPauseWarningFlap:
+    """``_tariff_pause_warned`` rate-limits the one-shot ``provider error''
+    warning when the tariff provider raises while ``solar_plus_cheap`` is
+    active. v1.6.3 review surfaced an unguarded code path: the original
+    factoring cleared the flag in two places (the EXPENSIVE branch and the
+    cheap-or-normal branch). The duplicated clear looked like a bug
+    (reviewer flagged it), but the actual invariant is
+    ``successful get_price_level() ⇒ flag cleared`` regardless of price.
+    The refactor pulled the clear above the price-level branch so the
+    invariant is local to one line. These tests pin that contract so a
+    future split-by-branch doesn't silently restore the multi-warn loop.
+    """
+
+    def _power(self, battery_soc=50):
+        return PowerReadings(
+            solar_power=2000.0, grid_power=-500.0, home_consumption_power=1500.0,
+            battery_power=0.0, battery_soc=battery_soc, ev_power=0.0,
+            ev_connected=True, ev_charging=False,
+        )
+
+    def _drive(self, coord, n=1):
+        """Run the daytime strategy ``n`` times for ``solar_plus_cheap``."""
+        cfg = {"id": "keba", "charge_mode": "solar_plus_cheap"}
+        coord.time_manager.is_night_mode = MagicMock(return_value=False)
+        for _ in range(n):
+            coord._determine_charging_strategy(
+                self._power(battery_soc=50), MagicMock(daily_ev=0.0), cfg,
+            )
+
+    def test_warning_emitted_once_per_provider_outage(self, caplog):
+        """A first provider error logs the warning; subsequent ticks
+        during the same outage do not re-fire it."""
+        coord = _build_coordinator(tariff_on=True)
+        coord._tariff_provider.get_price_level = MagicMock(
+            side_effect=RuntimeError("provider down"),
+        )
+
+        with caplog.at_level(logging.WARNING,
+                             logger="custom_components.solar_energy_management.coordinator.coordinator"):
+            self._drive(coord, n=5)
+
+        msgs = [r.message for r in caplog.records
+                if "Tariff-optimized daytime pause disabled" in r.message]
+        assert len(msgs) == 1, (
+            f"expected one warning across 5 ticks of a single outage; got {len(msgs)}"
+        )
+        assert coord._tariff_pause_warned is True
+
+    def test_flag_cleared_on_successful_call_even_when_price_expensive(self):
+        """Successful ``get_price_level()`` is the recovery signal — the
+        flag must clear regardless of whether the returned price is
+        CHEAP or EXPENSIVE. Pinning the v1.6.3 invariant: a provider
+        recovery during an expensive window still re-arms the next
+        warning rather than letting it silently re-fire."""
+        coord = _build_coordinator(tariff_on=True)
+        # Tick 1: provider errors → flag set
+        coord._tariff_provider.get_price_level = MagicMock(
+            side_effect=RuntimeError("provider down"),
+        )
+        self._drive(coord, n=1)
+        assert coord._tariff_pause_warned is True
+
+        # Tick 2: provider recovers but happens to return EXPENSIVE
+        # → flag MUST clear (EXPENSIVE return is still a successful call).
+        coord._tariff_provider.get_price_level = MagicMock(
+            return_value=PriceLevel.EXPENSIVE,
+        )
+        self._drive(coord, n=1)
+        assert coord._tariff_pause_warned is False, (
+            "successful read with EXPENSIVE price must clear the flag; "
+            "otherwise the next outage silently fails the rate-limit "
+            "because the flag is already True"
+        )
+
+    def test_flag_cleared_on_successful_call_with_cheap_price(self):
+        """Same invariant via the other branch — successful CHEAP read
+        also clears the flag."""
+        coord = _build_coordinator(tariff_on=True)
+        coord._tariff_provider.get_price_level = MagicMock(
+            side_effect=RuntimeError("provider down"),
+        )
+        self._drive(coord, n=1)
+        assert coord._tariff_pause_warned is True
+
+        coord._tariff_provider.get_price_level = MagicMock(
+            return_value=PriceLevel.CHEAP,
+        )
+        self._drive(coord, n=1)
+        assert coord._tariff_pause_warned is False
+
+    def test_warning_re_fires_after_recovery_then_new_outage(self, caplog):
+        """Recovery resets the rate-limit, so a fresh outage warns
+        again. This is the user-visible behaviour the suppression
+        wants: notify on transitions, not every tick of a continuous
+        outage."""
+        coord = _build_coordinator(tariff_on=True)
+
+        # Outage 1
+        coord._tariff_provider.get_price_level = MagicMock(
+            side_effect=RuntimeError("provider down"),
+        )
+        with caplog.at_level(logging.WARNING,
+                             logger="custom_components.solar_energy_management.coordinator.coordinator"):
+            self._drive(coord, n=3)
+
+            # Recovery
+            coord._tariff_provider.get_price_level = MagicMock(
+                return_value=PriceLevel.CHEAP,
+            )
+            self._drive(coord, n=2)
+
+            # Outage 2
+            coord._tariff_provider.get_price_level = MagicMock(
+                side_effect=RuntimeError("provider down again"),
+            )
+            self._drive(coord, n=3)
+
+        msgs = [r.message for r in caplog.records
+                if "Tariff-optimized daytime pause disabled" in r.message]
+        assert len(msgs) == 2, (
+            f"expected one warning per outage across 2 outages; got {len(msgs)}"
+        )
+
+
 # ---------------------------------------------------------------------------
 # Deadline floor in _execute_ev_control night branch (#246)
 # ---------------------------------------------------------------------------