Drop upnp options flow (#69134)

homeassistant/components/upnp/__init__.py

@@ -31,7 +31,6 @@ from homeassistant.helpers.update_coordinator import (
 from .const import (
     CONF_LOCAL_IP,
     CONFIG_ENTRY_HOSTNAME,
-    CONFIG_ENTRY_SCAN_INTERVAL,
     CONFIG_ENTRY_ST,
     CONFIG_ENTRY_UDN,
     DEFAULT_SCAN_INTERVAL,
@@ -163,10 +162,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         model=device.model_name,
     )
 
-    update_interval_sec = entry.options.get(
+    update_interval = timedelta(seconds=DEFAULT_SCAN_INTERVAL)
-        CONFIG_ENTRY_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
-    )
-    update_interval = timedelta(seconds=update_interval_sec)
     LOGGER.debug("update_interval: %s", update_interval)
     coordinator = UpnpDataUpdateCoordinator(
         hass,

homeassistant/components/upnp/config_flow.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Mapping
-from datetime import timedelta
 from typing import Any, cast
 
 import voluptuous as vol
@@ -11,16 +10,13 @@ import voluptuous as vol
 from homeassistant import config_entries
 from homeassistant.components import ssdp
 from homeassistant.components.ssdp import SsdpChange, SsdpServiceInfo
-from homeassistant.const import CONF_SCAN_INTERVAL
+from homeassistant.core import HomeAssistant
-from homeassistant.core import HomeAssistant, callback
 from homeassistant.data_entry_flow import FlowResult
 
 from .const import (
     CONFIG_ENTRY_HOSTNAME,
-    CONFIG_ENTRY_SCAN_INTERVAL,
     CONFIG_ENTRY_ST,
     CONFIG_ENTRY_UDN,
-    DEFAULT_SCAN_INTERVAL,
     DOMAIN,
     LOGGER,
     SSDP_SEARCH_TIMEOUT,
@@ -258,14 +254,6 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
         discovery = self._discoveries[0]
         return await self._async_create_entry_from_discovery(discovery)
 
-    @staticmethod
-    @callback
-    def async_get_options_flow(
-        config_entry: config_entries.ConfigEntry,
-    ) -> config_entries.OptionsFlow:
-        """Define the config flow to handle options."""
-        return UpnpOptionsFlowHandler(config_entry)
-
     async def _async_create_entry_from_discovery(
         self,
         discovery: SsdpServiceInfo,
@@ -283,38 +271,3 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
             CONFIG_ENTRY_HOSTNAME: discovery.ssdp_headers["_host"],
         }
         return self.async_create_entry(title=title, data=data)
-
-
-class UpnpOptionsFlowHandler(config_entries.OptionsFlow):
-    """Handle a UPnP options flow."""
-
-    def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
-        """Initialize."""
-        self.config_entry = config_entry
-
-    async def async_step_init(self, user_input: Mapping = None) -> FlowResult:
-        """Manage the options."""
-        if user_input is not None:
-            coordinator = self.hass.data[DOMAIN][self.config_entry.entry_id]
-            update_interval_sec = user_input.get(
-                CONFIG_ENTRY_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
-            )
-            update_interval = timedelta(seconds=update_interval_sec)
-            LOGGER.debug("Updating coordinator, update_interval: %s", update_interval)
-            coordinator.update_interval = update_interval
-            return self.async_create_entry(title="", data=user_input)
-
-        scan_interval = self.config_entry.options.get(
-            CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
-        )
-        return self.async_show_form(
-            step_id="init",
-            data_schema=vol.Schema(
-                {
-                    vol.Optional(
-                        CONF_SCAN_INTERVAL,
-                        default=scan_interval,
-                    ): vol.All(vol.Coerce(int), vol.Range(min=30)),
-                }
-            ),
-        )

homeassistant/components/upnp/const.py

@@ -20,7 +20,6 @@ WAN_STATUS = "wan_status"
 ROUTER_IP = "ip"
 ROUTER_UPTIME = "uptime"
 KIBIBYTE = 1024
-CONFIG_ENTRY_SCAN_INTERVAL = "scan_interval"
 CONFIG_ENTRY_ST = "st"
 CONFIG_ENTRY_UDN = "udn"
 CONFIG_ENTRY_HOSTNAME = "hostname"

tests/components/upnp/test_config_flow.py

@@ -1,21 +1,16 @@
 """Test UPnP/IGD config flow."""
 
-from datetime import timedelta
-
 import pytest
 
 from homeassistant import config_entries, data_entry_flow
 from homeassistant.components import ssdp
 from homeassistant.components.upnp.const import (
     CONFIG_ENTRY_HOSTNAME,
-    CONFIG_ENTRY_SCAN_INTERVAL,
     CONFIG_ENTRY_ST,
     CONFIG_ENTRY_UDN,
-    DEFAULT_SCAN_INTERVAL,
     DOMAIN,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.util import dt
 
 from .conftest import (
     TEST_DISCOVERY,
@@ -25,10 +20,9 @@ from .conftest import (
     TEST_ST,
     TEST_UDN,
     TEST_USN,
-    MockIgdDevice,
 )
 
-from tests.common import MockConfigEntry, async_fire_time_changed
+from tests.common import MockConfigEntry
 
 
 @pytest.mark.usefixtures(
@@ -90,7 +84,6 @@ async def test_flow_ssdp_discovery_ignored(hass: HomeAssistant):
             CONFIG_ENTRY_ST: TEST_ST,
             CONFIG_ENTRY_HOSTNAME: TEST_HOSTNAME,
         },
-        options={CONFIG_ENTRY_SCAN_INTERVAL: DEFAULT_SCAN_INTERVAL},
     )
     config_entry.add_to_hass(hass)
 
@@ -159,7 +152,6 @@ async def test_flow_import_already_configured(hass: HomeAssistant):
             CONFIG_ENTRY_ST: TEST_ST,
             CONFIG_ENTRY_HOSTNAME: TEST_HOSTNAME,
         },
-        options={CONFIG_ENTRY_SCAN_INTERVAL: DEFAULT_SCAN_INTERVAL},
     )
     config_entry.add_to_hass(hass)
 
@@ -181,69 +173,3 @@ async def test_flow_import_no_devices_found(hass: HomeAssistant):
     )
     assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
     assert result["reason"] == "no_devices_found"
-
-
-@pytest.mark.usefixtures("ssdp_instant_discovery", "mock_get_source_ip")
-async def test_options_flow(hass: HomeAssistant):
-    """Test options flow."""
-    # Set up config entry.
-    config_entry = MockConfigEntry(
-        domain=DOMAIN,
-        data={
-            CONFIG_ENTRY_UDN: TEST_UDN,
-            CONFIG_ENTRY_ST: TEST_ST,
-            CONFIG_ENTRY_HOSTNAME: TEST_HOSTNAME,
-        },
-        options={CONFIG_ENTRY_SCAN_INTERVAL: DEFAULT_SCAN_INTERVAL},
-    )
-    config_entry.add_to_hass(hass)
-    assert await hass.config_entries.async_setup(config_entry.entry_id) is True
-    await hass.async_block_till_done()
-
-    # Reset.
-    mock_device: MockIgdDevice = hass.data[DOMAIN][
-        config_entry.entry_id
-    ].device._igd_device
-    mock_device.traffic_times_polled = 0
-    mock_device.status_times_polled = 0
-
-    # Forward time, ensure single poll after 30 (default) seconds.
-    async_fire_time_changed(hass, dt.utcnow() + timedelta(seconds=31))
-    await hass.async_block_till_done()
-    assert mock_device.traffic_times_polled == 1
-    assert mock_device.status_times_polled == 1
-
-    # Options flow with no input results in form.
-    result = await hass.config_entries.options.async_init(
-        config_entry.entry_id,
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
-
-    # Options flow with input results in update to entry.
-    result2 = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        user_input={CONFIG_ENTRY_SCAN_INTERVAL: 60},
-    )
-    assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-    assert config_entry.options == {
-        CONFIG_ENTRY_SCAN_INTERVAL: 60,
-    }
-
-    # Forward time, ensure single poll after 60 seconds, still from original setting.
-    async_fire_time_changed(hass, dt.utcnow() + timedelta(seconds=61))
-    await hass.async_block_till_done()
-    assert mock_device.traffic_times_polled == 2
-    assert mock_device.status_times_polled == 2
-
-    # Now the updated interval takes effect.
-    # Forward time, ensure single poll after 120 seconds.
-    async_fire_time_changed(hass, dt.utcnow() + timedelta(seconds=121))
-    await hass.async_block_till_done()
-    assert mock_device.traffic_times_polled == 3
-    assert mock_device.status_times_polled == 3
-
-    # Forward time, ensure single poll after 180 seconds.
-    async_fire_time_changed(hass, dt.utcnow() + timedelta(seconds=181))
-    await hass.async_block_till_done()
-    assert mock_device.traffic_times_polled == 4
-    assert mock_device.status_times_polled == 4