Support importing legacy YAML config

Add support for importing legacy login information
from YAML config file as part of the config flow
upgrade process.

Co-authored-by: Claude Sonnet 4.5 [email protected]

Author: masterkoppa

homeassistant/components/waterfurnace/__init__.py

@@ -4,13 +4,15 @@
 
 import logging
 
+import voluptuous as vol
 from waterfurnace.waterfurnace import WaterFurnace, WFCredentialError, WFException
 
-from homeassistant.config_entries import ConfigEntry
+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import config_validation as cv, device_registry as dr
+from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
 from .coordinator import WaterFurnaceDataUpdateCoordinator
@@ -20,6 +22,31 @@
 
 PLATFORMS = [Platform.SENSOR]
 
+CONFIG_SCHEMA = vol.Schema(
+    {
+        DOMAIN: vol.Schema(
+            {
+                vol.Required(CONF_USERNAME): cv.string,
+                vol.Required(CONF_PASSWORD): cv.string,
+            }
+        )
+    },
+    extra=vol.ALLOW_EXTRA,
+)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up WaterFurnace from yaml configuration."""
+    if DOMAIN in config:
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN,
+                context={"source": SOURCE_IMPORT},
+                data=config[DOMAIN],
+            )
+        )
+    return True
+
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: WaterFurnaceConfigEntry

homeassistant/components/waterfurnace/config_flow.py

@@ -152,6 +152,29 @@ async def async_step_reauth_confirm(
             errors=errors,
         )
 
+    async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
+        """Handle import from YAML configuration."""
+        try:
+            info = await validate_input(self.hass, import_data)
+        except (CannotConnect, InvalidAuth):
+            _LOGGER.error(
+                "Failed to import WaterFurnace configuration from YAML. "
+                "Please verify your credentials and set up the integration via the UI"
+            )
+            return self.async_abort(reason="cannot_connect")
+        except Exception:
+            _LOGGER.exception("Unexpected error importing WaterFurnace configuration")
+            return self.async_abort(reason="unknown")
+
+        # Set unique ID based on GWID
+        await self.async_set_unique_id(info["gwid"])
+        self._abort_if_unique_id_configured()
+
+        return self.async_create_entry(
+            title=info["title"],
+            data=import_data,
+        )
+
 
 class CannotConnect(HomeAssistantError):
     """Error to indicate we cannot connect."""

homeassistant/components/waterfurnace/strings.json

@@ -2,8 +2,10 @@
   "config": {
     "abort": {
       "already_configured": "This device is already configured",
+      "cannot_connect": "Failed to import configuration from YAML. Please verify your credentials and set up the integration via the UI",
       "no_devices": "No devices found on this account",
       "reauth_successful": "Reauthentication successful",
+      "unknown": "Failed to import configuration from YAML due to an unexpected error. Please set up the integration via the UI",
       "wrong_account": "The credentials provided are for a different account"
     },
     "error": {

tests/components/waterfurnace/test_config_flow.py

@@ -409,3 +409,120 @@ async def test_reauth_flow_unexpected_error(
 
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {"base": "cannot_connect"}
+
+
+async def test_import_flow_success(
+    hass: HomeAssistant, mock_waterfurnace_client: Mock
+) -> None:
+    """Test successful import flow from YAML."""
+    result = cast(
+        dict[str, Any],
+        await hass.config_entries.flow.async_init(
+            DOMAIN,
+            context={"source": config_entries.SOURCE_IMPORT},
+            data={
+                CONF_USERNAME: "test_user",
+                CONF_PASSWORD: "test_password",
+            },
+        ),
+    )
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "WaterFurnace TEST_GWID_12345"
+    assert result["data"] == {
+        CONF_USERNAME: "test_user",
+        CONF_PASSWORD: "test_password",
+    }
+    assert result["result"].unique_id == "TEST_GWID_12345"
+
+
+async def test_import_flow_already_configured(
+    hass: HomeAssistant,
+    mock_waterfurnace_client: Mock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test import flow when device is already configured."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = cast(
+        dict[str, Any],
+        await hass.config_entries.flow.async_init(
+            DOMAIN,
+            context={"source": config_entries.SOURCE_IMPORT},
+            data={
+                CONF_USERNAME: "test_user",
+                CONF_PASSWORD: "test_password",
+            },
+        ),
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"
+
+
+async def test_import_flow_cannot_connect(
+    hass: HomeAssistant, mock_waterfurnace_client: Mock
+) -> None:
+    """Test import flow with connection error."""
+    mock_waterfurnace_client.login.side_effect = WFException("Connection failed")
+
+    result = cast(
+        dict[str, Any],
+        await hass.config_entries.flow.async_init(
+            DOMAIN,
+            context={"source": config_entries.SOURCE_IMPORT},
+            data={
+                CONF_USERNAME: "test_user",
+                CONF_PASSWORD: "test_password",
+            },
+        ),
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "cannot_connect"
+
+
+async def test_import_flow_invalid_auth(
+    hass: HomeAssistant, mock_waterfurnace_client: Mock
+) -> None:
+    """Test import flow with invalid credentials."""
+    mock_waterfurnace_client.login.side_effect = WFCredentialError(
+        "Invalid credentials"
+    )
+
+    result = cast(
+        dict[str, Any],
+        await hass.config_entries.flow.async_init(
+            DOMAIN,
+            context={"source": config_entries.SOURCE_IMPORT},
+            data={
+                CONF_USERNAME: "bad_user",
+                CONF_PASSWORD: "bad_password",
+            },
+        ),
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "cannot_connect"
+
+
+async def test_import_flow_unexpected_error(
+    hass: HomeAssistant, mock_waterfurnace_client: Mock
+) -> None:
+    """Test import flow with unexpected error."""
+    mock_waterfurnace_client.login.side_effect = Exception("Unexpected error")
+
+    result = cast(
+        dict[str, Any],
+        await hass.config_entries.flow.async_init(
+            DOMAIN,
+            context={"source": config_entries.SOURCE_IMPORT},
+            data={
+                CONF_USERNAME: "test_user",
+                CONF_PASSWORD: "test_password",
+            },
+        ),
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "cannot_connect"