Feat/reconfigure flow (#52)

alengwenus · web-flow · commit b19c8ac54231 · 2026-05-14T15:33:42.000+02:00
* Fix SmaEvChargerConfigFlow

* Add reconfigure flow

* Add tests for reconfigure flow
diff --git a/custom_components/smaev/__init__.py b/custom_components/smaev/__init__.py
@@ -4,7 +4,6 @@
 
 import logging
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
 
 import pysmaev.core
 import pysmaev.exceptions
@@ -77,12 +76,9 @@ async def async_setup_entry(
     except pysmaev.exceptions.SmaEvChargerAuthenticationError as exc:
         raise ConfigEntryAuthFailed from exc
 
-    if TYPE_CHECKING:
-        assert entry.unique_id
-
     device_info = DeviceInfo(
         configuration_url=url,
-        identifiers={(DOMAIN, entry.unique_id)},
+        identifiers={(DOMAIN, smaev_device_info["serial"])},
         manufacturer=smaev_device_info["manufacturer"],
         model=smaev_device_info["model"],
         name=smaev_device_info["name"],
diff --git a/custom_components/smaev/config_flow.py b/custom_components/smaev/config_flow.py
@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Mapping
 from typing import Any
 
 import homeassistant.helpers.config_validation as cv
@@ -38,9 +37,7 @@
 )
 
 
-async def validate_input(
-    hass: HomeAssistant, data: dict[str, Any]
-) -> tuple[dict[str, Any], dict[str, str]]:
+async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, str]:
     """Validate the user input allows us to connect."""
     session = async_get_clientsession(hass, verify_ssl=data[CONF_VERIFY_SSL])
 
@@ -51,7 +48,6 @@ async def validate_input(
     )
 
     errors: dict[str, str] = {}
-    device_info: dict[str, str] = {}
     try:
         await evcharger.open()
     except pysmaev.exceptions.SmaEvChargerConnectionError:
@@ -61,51 +57,71 @@ async def validate_input(
     except Exception:  # pylint: disable=broad-except
         _LOGGER.exception("Unexpected exception")
         errors[CONF_BASE] = "unknown"
-    else:
-        device_info = await evcharger.device_info()
 
     await evcharger.close()
-    return device_info, errors
+    return errors
 
 
 class SmaEvChargerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for SMA EV Charger."""
 
     VERSION = 1
+    MINOR_VERSION = 0
+
+    _config_data: dict[str, str]
+    _reconfigure_data: dict[str, str]
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
-        if user_input is None:
-            return self.async_show_form(
-                step_id="user", data_schema=STEP_USER_DATA_SCHEMA
-            )
-
-        device_info, errors = await validate_input(self.hass, user_input)
-
-        if errors:
-            return self.async_show_form(
-                step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
+        self._config_data = {}
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            self._async_abort_entries_match(
+                {
+                    CONF_HOST: user_input[CONF_HOST],
+                }
             )
 
-        await self.async_set_unique_id(device_info["serial"])
-        self._abort_if_unique_id_configured(updates=user_input)
-        return self.async_create_entry(title=user_input[CONF_HOST], data=user_input)
+            errors |= await validate_input(self.hass, user_input)
+            if not errors:
+                self._config_data.update(user_input)
+                return self.async_create_entry(
+                    title=user_input[CONF_HOST], data=self._config_data
+                )
 
-    async def async_step_reauth(
-        self, user_input: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Perform reauth upon an API authentication error."""
-        return await self.async_step_reauth_confirm()
+        return self.async_show_form(
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
+        )
 
-    async def async_step_reauth_confirm(
+    async def async_step_reconfigure(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Dialog that informs the user that reauth is required."""
-        if user_input is None:
-            return self.async_show_form(
-                step_id="reauth_confirm",
-                data_schema=vol.Schema({}),
+        """Handle the reconfigure step."""
+        errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
+        self._reconfigure_data = reconfigure_entry.data.copy()
+
+        if user_input is not None:
+            self._async_abort_entries_match(
+                {
+                    CONF_HOST: user_input[CONF_HOST],
+                }
             )
-        return await self.async_step_user()
+
+            self._reconfigure_data = user_input
+            errors |= await validate_input(self.hass, user_input)
+            if not errors:
+                return self.async_update_reload_and_abort(
+                    self._get_reconfigure_entry(), data=self._reconfigure_data
+                )
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=self.add_suggested_values_to_schema(
+                STEP_USER_DATA_SCHEMA, self._reconfigure_data
+            ),
+            errors=errors,
+        )
diff --git a/custom_components/smaev/translations/de.json b/custom_components/smaev/translations/de.json
@@ -12,9 +12,16 @@
         "title": "Richte den SMA EV Charger ein",
         "description": "Gib deine SMA EV Charger-Geräteinformation ein."
       },
-      "reauth_confirm": {
-        "title": "Integration erneut authentifizieren",
-        "description": "Die SMA EV Charger-Integration muss dein Konto erneut authentifizieren"
+      "reconfigure": {
+        "data": {
+          "host": "Host",
+          "username": "Benutzername",
+          "password": "Passwort",
+          "ssl": "Verwende ein SSL-Zertifikat",
+          "verify_ssl": "SSL-Zertifikat überprüfen"
+        },
+        "title": "SMA EV Charger neu konfigurieren",
+        "description": "Aktualisiere deine SMA EV Charger-Geräteinformationen."
       }
     },
     "error": {
@@ -24,7 +31,7 @@
     },
     "abort": {
       "already_configured": "Gerät ist bereits konfiguriert",
-      "reauth_successful": "Die erneute Authentifizierung war erfolgreich"
+      "reconfigure_successful": "Die Neukonfiguration war erfolgreich"
     }
   },
   "options": {
diff --git a/custom_components/smaev/translations/en.json b/custom_components/smaev/translations/en.json
@@ -12,9 +12,16 @@
         "title": "Set up SMA EV Charger",
         "description": "Enter your  SMA EV Charger device information."
       },
-      "reauth_confirm": {
-        "title": "Reauthenticate integration",
-        "description": "The SMA EV Charger integration needs to re-authenticate your account"
+      "reconfigure": {
+        "data": {
+          "host": "Host",
+          "username": "Username",
+          "password": "Password",
+          "ssl": "Use an SSL certificate",
+          "verify_ssl": "Verify SSL certificate"
+        },
+        "title": "Reconfigure SMA EV Charger",
+        "description": "Update your SMA EV Charger device information."
       }
     },
     "error": {
@@ -24,7 +31,7 @@
     },
     "abort": {
       "already_configured": "Device is already configured",
-      "reauth_successful": "Re-authentication was successful"
+      "reconfigure_successful": "Reconfigure successful."
     }
   },
   "options": {
diff --git a/tests/test_config_flow.py b/tests/test_config_flow.py
@@ -12,7 +12,7 @@
 from custom_components import smaev
 from custom_components.smaev.config_flow import SmaEvChargerConfigFlow, validate_input
 
-from .conftest import CONFIG_DATA, DEVICE_INFO, MockSmaEvCharger
+from .conftest import CONFIG_DATA, MockConfigEntry, MockSmaEvCharger
 
 
 async def test_show_form(hass: HomeAssistant) -> None:
@@ -76,53 +76,58 @@ async def test_step_user_error(hass, error, errors):
         assert result["errors"] == errors
 
 
-# @patch.object(pysmaev.core, "SmaEvCharger", MockSmaEvCharger)
-# async def test_options_flow(hass, entry):
-#     """Test config flow options."""
-#     entry.add_to_hass(hass)
-#     result = await hass.config_entries.options.async_init(entry.entry_id)
-
-#     assert result["type"] == data_entry_flow.FlowResultType.FORM
-#     assert result["step_id"] == "init"
-
-#     user_input = CONFIG_DATA.copy()
+@patch.object(pysmaev.core, "SmaEvCharger", MockSmaEvCharger)
+async def test_step_reconfigure(hass: HomeAssistant, entry: MockSmaEvCharger):
+    """Test for reconfigure step."""
+    entry.add_to_hass(hass)
+    old_entry_data = entry.data.copy()
 
-#     result = await hass.config_entries.options.async_configure(
-#         result["flow_id"], user_input=user_input
-#     )
+    result = await entry.start_reconfigure_flow(hass)
+    assert result["type"] == data_entry_flow.FlowResultType.FORM
+    assert result["step_id"] == "reconfigure"
 
-#     assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
-#     assert all(value == entry.data[key] for key, value in user_input.items())
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=CONFIG_DATA.copy()
+    )
+    assert result["type"] == data_entry_flow.FlowResultType.ABORT
+    assert result["reason"] == "reconfigure_successful"
 
+    entry = hass.config_entries.async_get_entry(entry.entry_id)
+    assert entry.data == {**old_entry_data, **CONFIG_DATA}
 
-# @pytest.mark.parametrize(
-#     ("error", "errors"),
-#     [
-#         (pysmaev.exceptions.SmaEvChargerConnectionError, {CONF_BASE: "cannot_connect"}),
-#         (
-#             pysmaev.exceptions.SmaEvChargerAuthenticationError,
-#             {CONF_BASE: "invalid_auth"},
-#         ),
-#         (Exception, {CONF_BASE: "unknown"}),
-#     ],
-# )
-# async def test_options_flow_errors(hass, entry, error, errors):
-#     """Test config flow options."""
-#     entry.add_to_hass(hass)
-#     result = await hass.config_entries.options.async_init(entry.entry_id)
 
-#     assert result["type"] == data_entry_flow.FlowResultType.FORM
-#     assert result["step_id"] == "init"
+@pytest.mark.parametrize(
+    ("error", "errors"),
+    [
+        (pysmaev.exceptions.SmaEvChargerConnectionError, {CONF_BASE: "cannot_connect"}),
+        (
+            pysmaev.exceptions.SmaEvChargerAuthenticationError,
+            {CONF_BASE: "invalid_auth"},
+        ),
+        (Exception, {CONF_BASE: "unknown"}),
+    ],
+)
+async def test_step_reconfigure_error(
+    hass: HomeAssistant,
+    entry: MockConfigEntry,
+    error: type[Exception],
+    errors: dict[str, str],
+) -> None:
+    """Test for error in reconfigure step is handled correctly."""
+    entry.add_to_hass(hass)
 
-#     user_input = CONFIG_DATA.copy()
+    result = await entry.start_reconfigure_flow(hass)
+    assert result["type"] == data_entry_flow.FlowResultType.FORM
+    assert result["step_id"] == "reconfigure"
 
-#     with patch("pysmaev.core.SmaEvCharger.open", side_effect=error):
-#         result = await hass.config_entries.options.async_configure(
-#             result["flow_id"], user_input=user_input
-#         )
+    with patch("pysmaev.core.SmaEvCharger.open", side_effect=error):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            CONFIG_DATA.copy(),
+        )
 
-#     assert result["type"] == data_entry_flow.FlowResultType.FORM
-#     assert result["errors"] == errors
+        assert result["type"] == data_entry_flow.FlowResultType.FORM
+        assert result["errors"] == errors
 
 
 async def test_validate_connection(hass: HomeAssistant):
@@ -134,7 +139,7 @@ async def test_validate_connection(hass: HomeAssistant):
 
     assert mock.open.is_called
     assert mock.device_info.is_called
-    assert result == (DEVICE_INFO, {})
+    assert result == {}
 
 
 @pytest.mark.parametrize(
@@ -155,4 +160,4 @@ async def test_validate_connection_raises_error(hass: HomeAssistant, error, erro
     with patch("pysmaev.core.SmaEvCharger.open", side_effect=error):
         result = await validate_input(hass, data=data)
 
-    assert result == ({}, errors)
+    assert result == errors
