Change supervisor_update_pending text

During onboarding, Supervisor may be out of date relative to the core
version being installed. Attempt a Supervisor update at the start of
async_setup_entry when not yet onboarded:

- SupervisorBadRequestError: no update available, proceed normally.
- No exception: update was triggered, raise ConfigEntryNotReady to
  retry once Supervisor has restarted with the new version.
- Any other SupervisorError: unexpected failure communicating with
  Supervisor, raise ConfigEntryNotReady to retry.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

homeassistant/components/hassio/__init__.py

@@ -8,7 +8,7 @@ import os
 import struct
 from typing import Any
 
-from aiohasupervisor import SupervisorError
+from aiohasupervisor import SupervisorBadRequestError, SupervisorError
 from aiohasupervisor.models import (
     GreenOptions,
     HomeAssistantOptions,
@@ -25,6 +25,7 @@ from homeassistant.components.http import (
     CONF_SERVER_PORT,
     CONF_SSL_CERTIFICATE,
 )
+from homeassistant.components.onboarding import async_is_onboarded
 from homeassistant.config_entries import SOURCE_SYSTEM, ConfigEntry
 from homeassistant.const import (
     EVENT_CORE_CONFIG_UPDATE,
@@ -301,6 +302,28 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             translation_key="supervisor_not_connected",
         ) from err
 
+    # During onboarding, Supervisor may be out of date. Attempt an update now
+    # so that core loads against an up-to-date Supervisor. A
+    # SupervisorBadRequestError means there is no update available, proceed
+    # normally. No exception means an update was triggered and we must wait for
+    # it to complete. Any other SupervisorError means something unexpected went
+    # wrong and we cannot proceed right now.
+    if not async_is_onboarded(hass):
+        try:
+            await supervisor_client.supervisor.update()
+        except SupervisorBadRequestError:
+            pass  # No update available, proceed normally.
+        except SupervisorError as err:
+            raise ConfigEntryNotReady(
+                translation_domain=DOMAIN,
+                translation_key="supervisor_not_connected",
+            ) from err
+        else:
+            raise ConfigEntryNotReady(
+                translation_domain=DOMAIN,
+                translation_key="supervisor_update_pending",
+            )
+
     # Get or create a refresh token for the Supervisor user
     user = hass.data[DATA_HASSIO_SUPERVISOR_USER]
     if user.refresh_tokens:

homeassistant/components/hassio/strings.json

@@ -55,6 +55,9 @@
     },
     "supervisor_not_connected": {
       "message": "Not connected with the supervisor / system too busy"
+    },
+    "supervisor_update_pending": {
+      "message": "Supervisor was out-of-date during onboarding. Update triggered, will retry when complete"
     }
   },
   "issues": {

homeassistant/components/overkiz/climate/atlantic_electrical_heater_with_adjustable_temperature_setpoint.py

@@ -57,6 +57,7 @@ OVERKIZ_TO_HVAC_MODE: dict[str, HVACMode] = {
     OverkizCommandParam.STANDBY: HVACMode.OFF,  # main command
     OverkizCommandParam.AUTO: HVACMode.AUTO,
     OverkizCommandParam.EXTERNAL: HVACMode.AUTO,
+    OverkizCommandParam.PROG: HVACMode.AUTO,
     OverkizCommandParam.INTERNAL: HVACMode.AUTO,  # main command
 }
 

homeassistant/components/tado/config_flow.py

@@ -40,6 +40,8 @@ class TadoConfigFlow(ConfigFlow, domain=DOMAIN):
     login_task: asyncio.Task | None = None
     refresh_token: str | None = None
     tado: Tado | None = None
+    tado_device_url: str = ""
+    user_code: str = ""
 
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
@@ -69,8 +71,8 @@ class TadoConfigFlow(ConfigFlow, domain=DOMAIN):
                 _LOGGER.exception("Error while initiating Tado")
                 return self.async_abort(reason="cannot_connect")
             assert self.tado is not None
-            tado_device_url = self.tado.device_verification_url()
-            user_code = URL(tado_device_url).query["user_code"]
+            self.tado_device_url = self.tado.device_verification_url()
+            self.user_code = URL(self.tado_device_url).query["user_code"]
 
         async def _wait_for_login() -> None:
             """Wait for the user to login."""
@@ -119,8 +121,8 @@ class TadoConfigFlow(ConfigFlow, domain=DOMAIN):
             step_id="user",
             progress_action="wait_for_device",
             description_placeholders={
-                "url": tado_device_url,
-                "code": user_code,
+                "url": self.tado_device_url,
+                "code": self.user_code,
             },
             progress_task=self.login_task,
         )

homeassistant/config_entries.py

@@ -138,6 +138,8 @@ SAVE_DELAY = 1
 
 DISCOVERY_COOLDOWN = 1
 
+SETUP_RETRY_MAX_WAIT = 600  # 10 minutes
+
 ISSUE_UNIQUE_ID_COLLISION = "config_entry_unique_id_collision"
 UNIQUE_ID_COLLISION_TITLE_LIMIT = 5
 
@@ -836,7 +838,7 @@ class ConfigEntry[_DataT = Any]:
                 error_reason_translation_key,
                 error_reason_translation_placeholders,
             )
-            wait_time = 2 ** min(self._tries, 4) * 5 + (
+            wait_time = min(2**self._tries * 5, SETUP_RETRY_MAX_WAIT) + (
                 randint(RANDOM_MICROSECOND_MIN, RANDOM_MICROSECOND_MAX) / 1000000
             )
             self._tries += 1

tests/components/duco/__init__.py

@@ -1 +1,33 @@
 """Tests for the Duco integration."""
+
+from collections.abc import Sequence
+from unittest.mock import patch
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from tests.common import MockConfigEntry
+
+
+async def setup_integration(
+    hass: HomeAssistant,
+    config_entry: MockConfigEntry,
+) -> MockConfigEntry:
+    """Set up the full Duco integration for testing."""
+    config_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(config_entry.entry_id)
+    await hass.async_block_till_done()
+    return config_entry
+
+
+async def setup_platform_integration(
+    hass: HomeAssistant,
+    config_entry: MockConfigEntry,
+    platforms: Sequence[Platform],
+) -> MockConfigEntry:
+    """Set up selected Duco platforms for testing."""
+    config_entry.add_to_hass(hass)
+    with patch("homeassistant.components.duco.PLATFORMS", list(platforms)):
+        await hass.config_entries.async_setup(config_entry.entry_id)
+        await hass.async_block_till_done()
+    return config_entry

tests/components/duco/conftest.py

@@ -23,6 +23,8 @@ from homeassistant.components.duco.const import DOMAIN
 from homeassistant.const import CONF_HOST
 from homeassistant.core import HomeAssistant
 
+from . import setup_integration
+
 from tests.common import MockConfigEntry, load_json_array_fixture
 
 TEST_HOST = "192.168.1.100"
@@ -159,112 +161,7 @@ def mock_lan_info() -> LanInfo:
 @pytest.fixture
 def mock_nodes() -> list[Node]:
     """Return a list of nodes covering all supported types."""
-    return [
-        Node(
-            node_id=1,
-            general=NodeGeneralInfo(
-                node_type="BOX",
-                sub_type=1,
-                network_type="VIRT",
-                parent=0,
-                asso=0,
-                name="Living",
-                identify=0,
-            ),
-            ventilation=NodeVentilationInfo(
-                state="AUTO",
-                time_state_remain=0,
-                time_state_end=0,
-                mode="AUTO",
-                flow_lvl_tgt=0,
-            ),
-            sensor=NodeSensorInfo(
-                co2=None,
-                iaq_co2=None,
-                rh=None,
-                iaq_rh=None,
-                temp=27.9,
-            ),
-        ),
-        Node(
-            node_id=2,
-            general=NodeGeneralInfo(
-                node_type="UCCO2",
-                sub_type=0,
-                network_type="RF",
-                parent=1,
-                asso=1,
-                name="Office CO2",
-                identify=0,
-            ),
-            ventilation=NodeVentilationInfo(
-                state="AUTO",
-                time_state_remain=0,
-                time_state_end=0,
-                mode="-",
-                flow_lvl_tgt=None,
-            ),
-            sensor=NodeSensorInfo(
-                co2=405,
-                iaq_co2=80,
-                rh=None,
-                iaq_rh=None,
-                temp=19.8,
-            ),
-        ),
-        Node(
-            node_id=113,
-            general=NodeGeneralInfo(
-                node_type="BSRH",
-                sub_type=0,
-                network_type="RF",
-                parent=1,
-                asso=1,
-                name="Bathroom RH",
-                identify=0,
-            ),
-            ventilation=NodeVentilationInfo(
-                state="AUTO",
-                time_state_remain=0,
-                time_state_end=0,
-                mode="-",
-                flow_lvl_tgt=None,
-            ),
-            sensor=NodeSensorInfo(
-                co2=None,
-                iaq_co2=None,
-                rh=42.0,
-                iaq_rh=85,
-                temp=27.9,
-            ),
-        ),
-        Node(
-            node_id=50,
-            general=NodeGeneralInfo(
-                node_type="UCRH",
-                sub_type=0,
-                network_type="RF",
-                parent=1,
-                asso=1,
-                name="Kitchen RH",
-                identify=0,
-            ),
-            ventilation=NodeVentilationInfo(
-                state="AUTO",
-                time_state_remain=0,
-                time_state_end=0,
-                mode="-",
-                flow_lvl_tgt=None,
-            ),
-            sensor=NodeSensorInfo(
-                co2=None,
-                iaq_co2=None,
-                rh=61.0,
-                iaq_rh=90,
-                temp=22.5,
-            ),
-        ),
-    ]
+    return load_nodes_fixture("nodes.json")
 
 
 @pytest.fixture
@@ -327,7 +224,4 @@ async def init_integration(
     mock_duco_client: AsyncMock,
 ) -> MockConfigEntry:
     """Set up the Duco integration for testing."""
-    mock_config_entry.add_to_hass(hass)
-    await hass.config_entries.async_setup(mock_config_entry.entry_id)
-    await hass.async_block_till_done()
-    return mock_config_entry
+    return await setup_integration(hass, mock_config_entry)

tests/components/duco/fixtures/nodes.json

@@ -0,0 +1,106 @@
+[
+  {
+    "node_id": 1,
+    "general": {
+      "node_type": "BOX",
+      "sub_type": 1,
+      "network_type": "VIRT",
+      "parent": 0,
+      "asso": 0,
+      "name": "Living",
+      "identify": 0
+    },
+    "ventilation": {
+      "state": "AUTO",
+      "time_state_remain": 0,
+      "time_state_end": 0,
+      "mode": "AUTO",
+      "flow_lvl_tgt": 0
+    },
+    "sensor": {
+      "co2": null,
+      "iaq_co2": null,
+      "rh": null,
+      "iaq_rh": null,
+      "temp": 27.9
+    }
+  },
+  {
+    "node_id": 2,
+    "general": {
+      "node_type": "UCCO2",
+      "sub_type": 0,
+      "network_type": "RF",
+      "parent": 1,
+      "asso": 1,
+      "name": "Office CO2",
+      "identify": 0
+    },
+    "ventilation": {
+      "state": "AUTO",
+      "time_state_remain": 0,
+      "time_state_end": 0,
+      "mode": "-",
+      "flow_lvl_tgt": null
+    },
+    "sensor": {
+      "co2": 405,
+      "iaq_co2": 80,
+      "rh": null,
+      "iaq_rh": null,
+      "temp": 19.8
+    }
+  },
+  {
+    "node_id": 113,
+    "general": {
+      "node_type": "BSRH",
+      "sub_type": 0,
+      "network_type": "RF",
+      "parent": 1,
+      "asso": 1,
+      "name": "Bathroom RH",
+      "identify": 0
+    },
+    "ventilation": {
+      "state": "AUTO",
+      "time_state_remain": 0,
+      "time_state_end": 0,
+      "mode": "-",
+      "flow_lvl_tgt": null
+    },
+    "sensor": {
+      "co2": null,
+      "iaq_co2": null,
+      "rh": 42.0,
+      "iaq_rh": 85,
+      "temp": 27.9
+    }
+  },
+  {
+    "node_id": 50,
+    "general": {
+      "node_type": "UCRH",
+      "sub_type": 0,
+      "network_type": "RF",
+      "parent": 1,
+      "asso": 1,
+      "name": "Kitchen RH",
+      "identify": 0
+    },
+    "ventilation": {
+      "state": "AUTO",
+      "time_state_remain": 0,
+      "time_state_end": 0,
+      "mode": "-",
+      "flow_lvl_tgt": null
+    },
+    "sensor": {
+      "co2": null,
+      "iaq_co2": null,
+      "rh": 61.0,
+      "iaq_rh": 90,
+      "temp": 22.5
+    }
+  }
+]

tests/components/duco/test_fan.py

@@ -1,7 +1,7 @@
 """Tests for the Duco fan platform."""
 
 import logging
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock
 
 from duco_connectivity import DucoConnectionError, DucoError, DucoRateLimitError
 from freezegun.api import FrozenDateTimeFactory
@@ -21,6 +21,8 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er
 
+from . import setup_platform_integration
+
 from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform
 
 _FAN_ENTITY = "fan.living"
@@ -33,11 +35,7 @@ async def init_integration(
     mock_duco_client: AsyncMock,
 ) -> MockConfigEntry:
     """Set up only the fan platform for testing."""
-    mock_config_entry.add_to_hass(hass)
-    with patch("homeassistant.components.duco.PLATFORMS", [Platform.FAN]):
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-    return mock_config_entry
+    return await setup_platform_integration(hass, mock_config_entry, [Platform.FAN])
 
 
 @pytest.mark.usefixtures("init_integration")

tests/components/duco/test_sensor.py

@@ -1,7 +1,7 @@
 """Tests for the Duco sensor platform."""
 
 import logging
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock
 
 from duco_connectivity import (
     DucoConnectionError,
@@ -22,6 +22,8 @@ from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 
+from . import setup_platform_integration
+
 from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform
 
 
@@ -34,11 +36,7 @@ async def init_integration(
 ) -> MockConfigEntry:
     """Set up only the sensor platform for testing."""
     mock_duco_client.async_get_nodes.return_value = mock_sensor_nodes
-    mock_config_entry.add_to_hass(hass)
-    with patch("homeassistant.components.duco.PLATFORMS", [Platform.SENSOR]):
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-    return mock_config_entry
+    return await setup_platform_integration(hass, mock_config_entry, [Platform.SENSOR])
 
 
 @pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")

tests/components/hassio/test_init.py

@@ -8,7 +8,7 @@ from typing import Any
 from unittest.mock import ANY, AsyncMock, Mock, call, patch
 from uuid import uuid4
 
-from aiohasupervisor import SupervisorError
+from aiohasupervisor import SupervisorBadRequestError, SupervisorError
 from aiohasupervisor.models import (
     AddonsStats,
     AddonStage,
@@ -191,6 +191,67 @@ async def test_setup_api_ping_fails(
     assert entry.state is ConfigEntryState.SETUP_RETRY
 
 
+async def test_setup_onboarding_supervisor_update(
+    hass: HomeAssistant,
+    supervisor_client: AsyncMock,
+) -> None:
+    """Test that during onboarding, supervisor.update() success triggers retry."""
+    with (
+        patch.dict(os.environ, MOCK_ENVIRON),
+        patch("homeassistant.components.hassio.async_is_onboarded", return_value=False),
+    ):
+        result = await async_setup_component(hass, "hassio", {})
+        await hass.async_block_till_done()
+
+    assert result
+    assert is_hassio(hass)
+    entry = hass.config_entries.async_entries("hassio")[0]
+    assert entry.state is ConfigEntryState.SETUP_RETRY
+    supervisor_client.supervisor.update.assert_called_once()
+
+
+async def test_setup_onboarding_supervisor_no_update(
+    hass: HomeAssistant,
+    supervisor_client: AsyncMock,
+) -> None:
+    """Test that during onboarding, SupervisorBadRequestError means no update needed."""
+    supervisor_client.supervisor.update.side_effect = SupervisorBadRequestError
+
+    with (
+        patch.dict(os.environ, MOCK_ENVIRON),
+        patch("homeassistant.components.hassio.async_is_onboarded", return_value=False),
+    ):
+        result = await async_setup_component(hass, "hassio", {})
+        await hass.async_block_till_done()
+
+    assert result
+    assert is_hassio(hass)
+    entry = hass.config_entries.async_entries("hassio")[0]
+    assert entry.state is ConfigEntryState.LOADED
+    supervisor_client.supervisor.update.assert_called_once()
+
+
+async def test_setup_onboarding_supervisor_update_error(
+    hass: HomeAssistant,
+    supervisor_client: AsyncMock,
+) -> None:
+    """Test that during onboarding, an unknown SupervisorError causes retry."""
+    supervisor_client.supervisor.update.side_effect = SupervisorError
+
+    with (
+        patch.dict(os.environ, MOCK_ENVIRON),
+        patch("homeassistant.components.hassio.async_is_onboarded", return_value=False),
+    ):
+        result = await async_setup_component(hass, "hassio", {})
+        await hass.async_block_till_done()
+
+    assert result
+    assert is_hassio(hass)
+    entry = hass.config_entries.async_entries("hassio")[0]
+    assert entry.state is ConfigEntryState.SETUP_RETRY
+    supervisor_client.supervisor.update.assert_called_once()
+
+
 async def test_setup_app_panel(hass: HomeAssistant) -> None:
     """Test app panel is registered."""
     with patch.dict(os.environ, MOCK_ENVIRON):

tests/components/tado/test_config_flow.py

@@ -231,6 +231,43 @@ async def test_options_flow(
     assert result["data"] == {CONF_FALLBACK: CONST_OVERLAY_TADO_DEFAULT}
 
 
+async def test_show_progress_polling(
+    hass: HomeAssistant,
+    mock_tado_api: MagicMock,
+    mock_setup_entry: AsyncMock,
+) -> None:
+    """Test progress step re-entry while login task is still running."""
+
+    event = threading.Event()
+
+    def mock_tado_api_device_activation() -> None:
+        event.wait(timeout=5)
+
+    mock_tado_api.device_activation = mock_tado_api_device_activation
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+    assert result["type"] is FlowResultType.SHOW_PROGRESS
+    assert result["step_id"] == "user"
+    assert result["description_placeholders"]["url"] is not None
+    assert result["description_placeholders"]["code"] == "TEST"
+
+    # Poll again while task is still running — this re-enters async_step_user
+    # with self.tado already set
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
+    assert result["type"] is FlowResultType.SHOW_PROGRESS
+    assert result["description_placeholders"]["url"] is not None
+    assert result["description_placeholders"]["code"] == "TEST"
+
+    # Now complete the login
+    event.set()
+    await hass.async_block_till_done()
+
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+
+
 async def test_homekit(hass: HomeAssistant, mock_tado_api: MagicMock) -> None:
     """Test that we abort from homekit if tado is already setup."""
 

tests/test_config_entries.py

@@ -1702,6 +1702,44 @@ async def test_setup_raise_not_ready(
     assert entry.reason is None
 
 
+async def test_setup_not_ready_exponential_backoff(
+    hass: HomeAssistant,
+    manager: config_entries.ConfigEntries,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """Test setup retry uses exponential backoff capped at 10 minutes."""
+    entry = MockConfigEntry(domain="test")
+    entry.add_to_hass(hass)
+
+    attempts = 0
+
+    async def _mock_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+        nonlocal attempts
+        attempts += 1
+        raise ConfigEntryNotReady
+
+    mock_integration(hass, MockModule("test", async_setup_entry=_mock_setup_entry))
+    mock_platform(hass, "test.config_flow", None)
+
+    await manager.async_setup(entry.entry_id)
+    assert attempts == 1
+
+    expected_waits = [5, 10, 20, 40, 80, 160, 320, 600, 600]
+    for i, wait in enumerate(expected_waits):
+        # Advance to just before the retry should fire
+        freezer.tick(wait - 1)
+        async_fire_time_changed(hass)
+        await hass.async_block_till_done()
+        assert attempts == i + 1, f"Retry {i + 1} fired too early"
+
+        # Advance past the retry point (+ 1s for jitter)
+        freezer.tick(2)
+        async_fire_time_changed(hass)
+        await hass.async_block_till_done()
+        assert attempts == i + 2, f"Retry {i + 1} did not fire"
+        assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY
+
+
 async def test_setup_raise_not_ready_from_exception(
     hass: HomeAssistant,
     manager: config_entries.ConfigEntries,