Add reconfigure flow to Duck DNS (home-assistant#157948)

Author: tr4nt0r

homeassistant/components/duckdns/config_flow.py

@@ -8,7 +8,7 @@
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN, CONF_NAME
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import (
     TextSelector,
@@ -31,6 +31,8 @@
     }
 )
 
+STEP_RECONFIGURE_DATA_SCHEMA = vol.Schema({vol.Required(CONF_ACCESS_TOKEN): str})
+
 
 class DuckDnsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Duck DNS."""
@@ -79,3 +81,37 @@ async def async_step_import(self, import_info: dict[str, Any]) -> ConfigFlowResu
 
         deprecate_yaml_issue(self.hass, import_success=True)
         return result
+
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfigure flow."""
+        errors: dict[str, str] = {}
+
+        entry = self._get_reconfigure_entry()
+
+        if user_input is not None:
+            session = async_get_clientsession(self.hass)
+            try:
+                if not await _update_duckdns(
+                    session,
+                    entry.data[CONF_DOMAIN],
+                    user_input[CONF_ACCESS_TOKEN],
+                ):
+                    errors["base"] = "update_failed"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+
+            if not errors:
+                return self.async_update_reload_and_abort(
+                    entry,
+                    data_updates=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=STEP_RECONFIGURE_DATA_SCHEMA,
+            errors=errors,
+            description_placeholders={CONF_NAME: entry.title},
+        )

homeassistant/components/duckdns/strings.json

@@ -1,13 +1,23 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
     },
     "error": {
       "unknown": "[%key:common::config_flow::error::unknown%]",
       "update_failed": "Updating Duck DNS failed"
     },
     "step": {
+      "reconfigure": {
+        "data": {
+          "access_token": "[%key:component::duckdns::config::step::user::data::access_token%]"
+        },
+        "data_description": {
+          "access_token": "[%key:component::duckdns::config::step::user::data_description::access_token%]"
+        },
+        "title": "Re-configure {name}"
+      },
       "user": {
         "data": {
           "access_token": "Token",

tests/components/duckdns/conftest.py

@@ -12,6 +12,7 @@
 
 TEST_SUBDOMAIN = "homeassistant"
 TEST_TOKEN = "123e4567-e89b-12d3-a456-426614174000"
+NEW_TOKEN = "11111111-2222-3333-4444-55555555"
 
 
 @pytest.fixture

tests/components/duckdns/test_config_flow.py

@@ -4,15 +4,15 @@
 
 import pytest
 
-from homeassistant.components.duckdns.const import DOMAIN
+from homeassistant.components.duckdns import DOMAIN
 from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_USER
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
 from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.helpers import issue_registry as ir
 from homeassistant.setup import async_setup_component
 
-from .conftest import TEST_SUBDOMAIN, TEST_TOKEN
+from .conftest import NEW_TOKEN, TEST_SUBDOMAIN, TEST_TOKEN
 
 from tests.common import MockConfigEntry
 
@@ -72,58 +72,26 @@ async def test_form_already_configured(
     assert result["reason"] == "already_configured"
 
 
-async def test_form_unknown_exception(
+@pytest.mark.parametrize(
+    ("side_effect", "text_error"),
+    [
+        ([ValueError, True], "unknown"),
+        ([False, True], "update_failed"),
+    ],
+)
+async def test_form_errors(
     hass: HomeAssistant,
     mock_setup_entry: AsyncMock,
     mock_update_duckdns: AsyncMock,
+    side_effect: list[Exception | bool],
+    text_error: str,
 ) -> None:
-    """Test we handle unknown exception."""
+    """Test we handle errors."""
     result = await hass.config_entries.flow.async_init(
         DOMAIN, context={"source": SOURCE_USER}
     )
-    mock_update_duckdns.side_effect = ValueError
-
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        {
-            CONF_DOMAIN: TEST_SUBDOMAIN,
-            CONF_ACCESS_TOKEN: TEST_TOKEN,
-        },
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["errors"] == {"base": "unknown"}
-
-    mock_update_duckdns.side_effect = None
-
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        {
-            CONF_DOMAIN: TEST_SUBDOMAIN,
-            CONF_ACCESS_TOKEN: TEST_TOKEN,
-        },
-    )
+    mock_update_duckdns.side_effect = side_effect
 
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["title"] == f"{TEST_SUBDOMAIN}.duckdns.org"
-    assert result["data"] == {
-        CONF_DOMAIN: TEST_SUBDOMAIN,
-        CONF_ACCESS_TOKEN: TEST_TOKEN,
-    }
-    assert len(mock_setup_entry.mock_calls) == 1
-
-
-async def test_form_update_failed(
-    hass: HomeAssistant,
-    mock_setup_entry: AsyncMock,
-    mock_update_duckdns: AsyncMock,
-) -> None:
-    """Test we handle cannot connect error."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-
-    mock_update_duckdns.return_value = False
     result = await hass.config_entries.flow.async_configure(
         result["flow_id"],
         {
@@ -133,9 +101,8 @@ async def test_form_update_failed(
     )
 
     assert result["type"] is FlowResultType.FORM
-    assert result["errors"] == {"base": "update_failed"}
+    assert result["errors"] == {"base": text_error}
 
-    mock_update_duckdns.return_value = True
     result = await hass.config_entries.flow.async_configure(
         result["flow_id"],
         {
@@ -253,3 +220,73 @@ async def test_init_import_flow(
     )
     assert len(mock_setup_entry.mock_calls) == 1
     assert len(hass.config_entries.async_entries(DOMAIN)) == 1
+
+
+@pytest.mark.usefixtures("mock_update_duckdns")
+async def test_flow_reconfigure(
+    hass: HomeAssistant,
+    mock_setup_entry: AsyncMock,
+    config_entry: MockConfigEntry,
+) -> None:
+    """Test reconfigure flow."""
+
+    config_entry.add_to_hass(hass)
+    result = await config_entry.start_reconfigure_flow(hass)
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "reconfigure"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_ACCESS_TOKEN: NEW_TOKEN},
+    )
+
+    await hass.async_block_till_done()
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "reconfigure_successful"
+    assert config_entry.data[CONF_ACCESS_TOKEN] == NEW_TOKEN
+
+
+@pytest.mark.parametrize(
+    ("side_effect", "text_error"),
+    [
+        ([ValueError, True], "unknown"),
+        ([False, True], "update_failed"),
+    ],
+)
+async def test_flow_reconfigure_errors(
+    hass: HomeAssistant,
+    mock_setup_entry: AsyncMock,
+    mock_update_duckdns: AsyncMock,
+    config_entry: MockConfigEntry,
+    side_effect: list[Exception | bool],
+    text_error: str,
+) -> None:
+    """Test we handle errors."""
+
+    config_entry.add_to_hass(hass)
+    result = await config_entry.start_reconfigure_flow(hass)
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "reconfigure"
+
+    mock_update_duckdns.side_effect = side_effect
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_ACCESS_TOKEN: NEW_TOKEN},
+    )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"] == {"base": text_error}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_ACCESS_TOKEN: NEW_TOKEN},
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "reconfigure_successful"
+
+    assert config_entry.data[CONF_ACCESS_TOKEN] == NEW_TOKEN