Remove YAML configuration from Jandy iAqualink (#72404)

homeassistant/components/iaqualink/__init__.py

@@ -19,9 +19,7 @@ from iaqualink.device import (
 )
 from iaqualink.exception import AqualinkServiceException
 from typing_extensions import Concatenate, ParamSpec
-import voluptuous as vol
 
-from homeassistant import config_entries
 from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
 from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
 from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
@@ -32,14 +30,12 @@ from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.dispatcher import (
     async_dispatcher_connect,
     async_dispatcher_send,
 )
 from homeassistant.helpers.entity import DeviceInfo, Entity
 from homeassistant.helpers.event import async_track_time_interval
-from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN, UPDATE_INTERVAL
 
@@ -52,42 +48,13 @@ ATTR_CONFIG = "config"
 PARALLEL_UPDATES = 0
 
 PLATFORMS = [
-    BINARY_SENSOR_DOMAIN,
-    CLIMATE_DOMAIN,
-    LIGHT_DOMAIN,
-    SENSOR_DOMAIN,
-    SWITCH_DOMAIN,
+    Platform.BINARY_SENSOR,
+    Platform.CLIMATE,
+    Platform.LIGHT,
+    Platform.SENSOR,
+    Platform.SWITCH,
 ]
 
-CONFIG_SCHEMA = vol.Schema(
-    vol.All(
-        cv.deprecated(DOMAIN),
-        {
-            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 the Aqualink component."""
-    if (conf := config.get(DOMAIN)) is not None:
-        hass.async_create_task(
-            hass.config_entries.flow.async_init(
-                DOMAIN,
-                context={"source": config_entries.SOURCE_IMPORT},
-                data=conf,
-            )
-        )
-
-    return True
-
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Aqualink from a config entry."""

homeassistant/components/iaqualink/config_flow.py

@@ -12,6 +12,7 @@ import voluptuous as vol
 
 from homeassistant import config_entries
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+from homeassistant.data_entry_flow import FlowResult
 
 from .const import DOMAIN
 
@@ -21,7 +22,9 @@ class AqualinkFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    async def async_step_user(self, user_input: dict[str, Any] | None = None):
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
         """Handle a flow start."""
         # Supporting a single account.
         entries = self._async_current_entries()
@@ -54,7 +57,3 @@ class AqualinkFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
             ),
             errors=errors,
         )
-
-    async def async_step_import(self, user_input: dict[str, Any] | None = None):
-        """Occurs when an entry is setup through config."""
-        return await self.async_step_user(user_input)

tests/components/iaqualink/test_config_flow.py

@@ -5,13 +5,11 @@ from iaqualink.exception import (
     AqualinkServiceException,
     AqualinkServiceUnauthorizedException,
 )
-import pytest
 
 from homeassistant.components.iaqualink import config_flow
 
 
-@pytest.mark.parametrize("step", ["import", "user"])
-async def test_already_configured(hass, config_entry, config_data, step):
+async def test_already_configured(hass, config_entry, config_data):
     """Test config flow when iaqualink component is already setup."""
     config_entry.add_to_hass(hass)
 
@@ -19,81 +17,67 @@ async def test_already_configured(hass, config_entry, config_data, step):
     flow.hass = hass
     flow.context = {}
 
-    fname = f"async_step_{step}"
-    func = getattr(flow, fname)
-    result = await func(config_data)
+    result = await flow.async_step_user(config_data)
 
     assert result["type"] == "abort"
 
 
-@pytest.mark.parametrize("step", ["import", "user"])
-async def test_without_config(hass, step):
+async def test_without_config(hass):
     """Test config flow with no configuration."""
     flow = config_flow.AqualinkFlowHandler()
     flow.hass = hass
     flow.context = {}
 
-    fname = f"async_step_{step}"
-    func = getattr(flow, fname)
-    result = await func()
+    result = await flow.async_step_user()
 
     assert result["type"] == "form"
     assert result["step_id"] == "user"
     assert result["errors"] == {}
 
 
-@pytest.mark.parametrize("step", ["import", "user"])
-async def test_with_invalid_credentials(hass, config_data, step):
+async def test_with_invalid_credentials(hass, config_data):
     """Test config flow with invalid username and/or password."""
     flow = config_flow.AqualinkFlowHandler()
     flow.hass = hass
 
-    fname = f"async_step_{step}"
-    func = getattr(flow, fname)
     with patch(
         "homeassistant.components.iaqualink.config_flow.AqualinkClient.login",
         side_effect=AqualinkServiceUnauthorizedException,
     ):
-        result = await func(config_data)
+        result = await flow.async_step_user(config_data)
 
     assert result["type"] == "form"
     assert result["step_id"] == "user"
     assert result["errors"] == {"base": "invalid_auth"}
 
 
-@pytest.mark.parametrize("step", ["import", "user"])
-async def test_service_exception(hass, config_data, step):
+async def test_service_exception(hass, config_data):
     """Test config flow encountering service exception."""
     flow = config_flow.AqualinkFlowHandler()
     flow.hass = hass
 
-    fname = f"async_step_{step}"
-    func = getattr(flow, fname)
     with patch(
         "homeassistant.components.iaqualink.config_flow.AqualinkClient.login",
         side_effect=AqualinkServiceException,
     ):
-        result = await func(config_data)
+        result = await flow.async_step_user(config_data)
 
     assert result["type"] == "form"
     assert result["step_id"] == "user"
     assert result["errors"] == {"base": "cannot_connect"}
 
 
-@pytest.mark.parametrize("step", ["import", "user"])
-async def test_with_existing_config(hass, config_data, step):
+async def test_with_existing_config(hass, config_data):
     """Test config flow with existing configuration."""
     flow = config_flow.AqualinkFlowHandler()
     flow.hass = hass
     flow.context = {}
 
-    fname = f"async_step_{step}"
-    func = getattr(flow, fname)
     with patch(
         "homeassistant.components.iaqualink.config_flow.AqualinkClient.login",
         return_value=None,
     ):
-        result = await func(config_data)
+        result = await flow.async_step_user(config_data)
 
     assert result["type"] == "create_entry"
     assert result["title"] == config_data["username"]