Remove yaml configuration from fritzbox (#49663)

CODEOWNERS

@@ -165,6 +165,7 @@ homeassistant/components/fortios/* @kimfrellsen
 homeassistant/components/foscam/* @skgsergio
 homeassistant/components/freebox/* @hacf-fr @Quentame
 homeassistant/components/fritz/* @mammuth @AaronDavidSchneider @chemelli74
+homeassistant/components/fritzbox/* @mib1185
 homeassistant/components/fronius/* @nielstron
 homeassistant/components/frontend/* @home-assistant/frontend
 homeassistant/components/garmin_connect/* @cyberjunky

homeassistant/components/fritzbox/__init__.py

@@ -3,19 +3,16 @@ from __future__ import annotations
 
 import asyncio
 from datetime import timedelta
-import socket
 
 from pyfritzhome import Fritzhome, FritzhomeDevice, LoginError
 import requests
-import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     ATTR_DEVICE_CLASS,
     ATTR_ENTITY_ID,
     ATTR_NAME,
     ATTR_UNIT_OF_MEASUREMENT,
-    CONF_DEVICES,
     CONF_HOST,
     CONF_PASSWORD,
     CONF_USERNAME,
@@ -23,73 +20,12 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
-import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.update_coordinator import (
     CoordinatorEntity,
     DataUpdateCoordinator,
 )
 
-from .const import (
+from .const import CONF_CONNECTIONS, CONF_COORDINATOR, DOMAIN, LOGGER, PLATFORMS
-    CONF_CONNECTIONS,
-    CONF_COORDINATOR,
-    DEFAULT_HOST,
-    DEFAULT_USERNAME,
-    DOMAIN,
-    LOGGER,
-    PLATFORMS,
-)
-
-
-def ensure_unique_hosts(value):
-    """Validate that all configs have a unique host."""
-    vol.Schema(vol.Unique("duplicate host entries found"))(
-        [socket.gethostbyname(entry[CONF_HOST]) for entry in value]
-    )
-    return value
-
-
-CONFIG_SCHEMA = vol.Schema(
-    vol.All(
-        cv.deprecated(DOMAIN),
-        {
-            DOMAIN: vol.Schema(
-                {
-                    vol.Required(CONF_DEVICES): vol.All(
-                        cv.ensure_list,
-                        [
-                            vol.Schema(
-                                {
-                                    vol.Required(
-                                        CONF_HOST, default=DEFAULT_HOST
-                                    ): cv.string,
-                                    vol.Required(CONF_PASSWORD): cv.string,
-                                    vol.Required(
-                                        CONF_USERNAME, default=DEFAULT_USERNAME
-                                    ): cv.string,
-                                }
-                            )
-                        ],
-                        ensure_unique_hosts,
-                    )
-                }
-            )
-        },
-    ),
-    extra=vol.ALLOW_EXTRA,
-)
-
-
-async def async_setup(hass: HomeAssistant, config: dict[str, str]) -> bool:
-    """Set up the AVM Fritz!Box integration."""
-    if DOMAIN in config:
-        for entry_config in config[DOMAIN][CONF_DEVICES]:
-            hass.async_create_task(
-                hass.config_entries.flow.async_init(
-                    DOMAIN, context={"source": SOURCE_IMPORT}, data=entry_config
-                )
-            )
-
-    return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

homeassistant/components/fritzbox/config_flow.py

@@ -88,10 +88,6 @@ class FritzboxConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         except OSError:
             return RESULT_NO_DEVICES_FOUND
 
-    async def async_step_import(self, user_input=None):
-        """Handle configuration by yaml file."""
-        return await self.async_step_user(user_input)
-
     async def async_step_user(self, user_input=None):
         """Handle a flow initialized by the user."""
         errors = {}

homeassistant/components/fritzbox/manifest.json

@@ -8,7 +8,7 @@
       "st": "urn:schemas-upnp-org:device:fritzbox:1"
     }
   ],
-  "codeowners": [],
+  "codeowners": ["@mib1185"],
   "config_flow": true,
   "iot_class": "local_polling"
 }

tests/components/fritzbox/__init__.py

@@ -1,8 +1,14 @@
 """Tests for the AVM Fritz!Box integration."""
+from __future__ import annotations
+
+from typing import Any
 from unittest.mock import Mock
 
 from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.const import CONF_DEVICES, CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+
+from tests.common import MockConfigEntry
 
 MOCK_CONFIG = {
     DOMAIN: {
@@ -17,6 +23,28 @@ MOCK_CONFIG = {
 }
 
 
+async def setup_config_entry(
+    hass: HomeAssistant,
+    data: dict[str, Any],
+    unique_id: str = "any",
+    device: Mock = None,
+    fritz: Mock = None,
+) -> bool:
+    """Do setup of a MockConfigEntry."""
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        data=data,
+        unique_id=unique_id,
+    )
+    entry.add_to_hass(hass)
+    if device is not None and fritz is not None:
+        fritz().get_devices.return_value = [device]
+    result = await hass.config_entries.async_setup(entry.entry_id)
+    if device is not None:
+        await hass.async_block_till_done()
+    return result
+
+
 class FritzDeviceBinarySensorMock(Mock):
     """Mock of a AVM Fritz!Box binary sensor device."""
 

tests/components/fritzbox/conftest.py

@@ -7,8 +7,7 @@ import pytest
 @pytest.fixture(name="fritz")
 def fritz_fixture() -> Mock:
     """Patch libraries."""
-    with patch("homeassistant.components.fritzbox.socket") as socket, patch(
+    with patch("homeassistant.components.fritzbox.Fritzhome") as fritz, patch(
-        "homeassistant.components.fritzbox.Fritzhome"
+        "homeassistant.components.fritzbox.config_flow.Fritzhome"
-    ) as fritz, patch("homeassistant.components.fritzbox.config_flow.Fritzhome"):
+    ):
-        socket.gethostbyname.return_value = "FAKE_IP_ADDRESS"
         yield fritz

tests/components/fritzbox/test_binary_sensor.py

@@ -10,34 +10,28 @@ from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
 from homeassistant.const import (
     ATTR_DEVICE_CLASS,
     ATTR_FRIENDLY_NAME,
+    CONF_DEVICES,
     STATE_OFF,
     STATE_ON,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.setup import async_setup_component
 import homeassistant.util.dt as dt_util
 
-from . import MOCK_CONFIG, FritzDeviceBinarySensorMock
+from . import MOCK_CONFIG, FritzDeviceBinarySensorMock, setup_config_entry
 
 from tests.common import async_fire_time_changed
 
 ENTITY_ID = f"{DOMAIN}.fake_name"
 
 
-async def setup_fritzbox(hass: HomeAssistant, config: dict):
-    """Set up mock AVM Fritz!Box."""
-    assert await async_setup_component(hass, FB_DOMAIN, config)
-    await hass.async_block_till_done()
-
-
 async def test_setup(hass: HomeAssistant, fritz: Mock):
     """Test setup of platform."""
     device = FritzDeviceBinarySensorMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
-
     assert state
     assert state.state == STATE_ON
     assert state.attributes[ATTR_FRIENDLY_NAME] == "fake_name"
@@ -48,11 +42,11 @@ async def test_is_off(hass: HomeAssistant, fritz: Mock):
     """Test state of platform."""
     device = FritzDeviceBinarySensorMock()
     device.present = False
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
-
     assert state
     assert state.state == STATE_OFF
 
@@ -60,9 +54,9 @@ async def test_is_off(hass: HomeAssistant, fritz: Mock):
 async def test_update(hass: HomeAssistant, fritz: Mock):
     """Test update without error."""
     device = FritzDeviceBinarySensorMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert device.update.call_count == 1
     assert fritz().login.call_count == 1
@@ -79,9 +73,9 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock):
     """Test update with error."""
     device = FritzDeviceBinarySensorMock()
     device.update.side_effect = [mock.DEFAULT, HTTPError("Boom")]
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert device.update.call_count == 1
     assert fritz().login.call_count == 1

tests/components/fritzbox/test_climate.py

@@ -35,32 +35,26 @@ from homeassistant.const import (
     ATTR_ENTITY_ID,
     ATTR_FRIENDLY_NAME,
     ATTR_TEMPERATURE,
+    CONF_DEVICES,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.setup import async_setup_component
 import homeassistant.util.dt as dt_util
 
-from . import MOCK_CONFIG, FritzDeviceClimateMock
+from . import MOCK_CONFIG, FritzDeviceClimateMock, setup_config_entry
 
 from tests.common import async_fire_time_changed
 
 ENTITY_ID = f"{DOMAIN}.fake_name"
 
 
-async def setup_fritzbox(hass: HomeAssistant, config: dict):
-    """Set up mock AVM Fritz!Box."""
-    assert await async_setup_component(hass, FB_DOMAIN, config) is True
-    await hass.async_block_till_done()
-
-
 async def test_setup(hass: HomeAssistant, fritz: Mock):
     """Test setup of platform."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
-
     assert state
     assert state.attributes[ATTR_BATTERY_LEVEL] == 23
     assert state.attributes[ATTR_CURRENT_TEMPERATURE] == 18
@@ -83,10 +77,11 @@ async def test_setup(hass: HomeAssistant, fritz: Mock):
 async def test_target_temperature_on(hass: HomeAssistant, fritz: Mock):
     """Test turn device on."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
     device.target_temperature = 127.0
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
     assert state
     assert state.attributes[ATTR_TEMPERATURE] == 30
@@ -95,10 +90,11 @@ async def test_target_temperature_on(hass: HomeAssistant, fritz: Mock):
 async def test_target_temperature_off(hass: HomeAssistant, fritz: Mock):
     """Test turn device on."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
     device.target_temperature = 126.5
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
     assert state
     assert state.attributes[ATTR_TEMPERATURE] == 0
@@ -107,11 +103,11 @@ async def test_target_temperature_off(hass: HomeAssistant, fritz: Mock):
 async def test_update(hass: HomeAssistant, fritz: Mock):
     """Test update without error."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
-
     assert state
     assert state.attributes[ATTR_CURRENT_TEMPERATURE] == 18
     assert state.attributes[ATTR_MAX_TEMP] == 28
@@ -136,9 +132,10 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock):
     """Test update with error."""
     device = FritzDeviceClimateMock()
     device.update.side_effect = HTTPError("Boom")
-    fritz().get_devices.return_value = [device]
+    assert not await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     assert device.update.call_count == 1
     assert fritz().login.call_count == 1
 
@@ -153,9 +150,9 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock):
 async def test_set_temperature_temperature(hass: HomeAssistant, fritz: Mock):
     """Test setting temperature by temperature."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN,
@@ -169,9 +166,9 @@ async def test_set_temperature_temperature(hass: HomeAssistant, fritz: Mock):
 async def test_set_temperature_mode_off(hass: HomeAssistant, fritz: Mock):
     """Test setting temperature by mode."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN,
@@ -189,9 +186,9 @@ async def test_set_temperature_mode_off(hass: HomeAssistant, fritz: Mock):
 async def test_set_temperature_mode_heat(hass: HomeAssistant, fritz: Mock):
     """Test setting temperature by mode."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN,
@@ -209,9 +206,9 @@ async def test_set_temperature_mode_heat(hass: HomeAssistant, fritz: Mock):
 async def test_set_hvac_mode_off(hass: HomeAssistant, fritz: Mock):
     """Test setting hvac mode."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN,
@@ -225,9 +222,9 @@ async def test_set_hvac_mode_off(hass: HomeAssistant, fritz: Mock):
 async def test_set_hvac_mode_heat(hass: HomeAssistant, fritz: Mock):
     """Test setting hvac mode."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN,
@@ -241,9 +238,9 @@ async def test_set_hvac_mode_heat(hass: HomeAssistant, fritz: Mock):
 async def test_set_preset_mode_comfort(hass: HomeAssistant, fritz: Mock):
     """Test setting preset mode."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN,
@@ -257,9 +254,9 @@ async def test_set_preset_mode_comfort(hass: HomeAssistant, fritz: Mock):
 async def test_set_preset_mode_eco(hass: HomeAssistant, fritz: Mock):
     """Test setting preset mode."""
     device = FritzDeviceClimateMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN,
@@ -275,11 +272,11 @@ async def test_preset_mode_update(hass: HomeAssistant, fritz: Mock):
     device = FritzDeviceClimateMock()
     device.comfort_temperature = 98
     device.eco_temperature = 99
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
-
     assert state
     assert state.attributes[ATTR_PRESET_MODE] is None
 

tests/components/fritzbox/test_config_flow.py

@@ -12,12 +12,7 @@ from homeassistant.components.ssdp import (
     ATTR_UPNP_FRIENDLY_NAME,
     ATTR_UPNP_UDN,
 )
-from homeassistant.config_entries import (
+from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_SSDP, SOURCE_USER
-    SOURCE_IMPORT,
-    SOURCE_REAUTH,
-    SOURCE_SSDP,
-    SOURCE_USER,
-)
 from homeassistant.const import CONF_DEVICES, CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import (
@@ -184,19 +179,6 @@ async def test_reauth_not_successful(hass: HomeAssistant, fritz: Mock):
     assert result["reason"] == "no_devices_found"
 
 
-async def test_import(hass: HomeAssistant, fritz: Mock):
-    """Test starting a flow by import."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_IMPORT}, data=MOCK_USER_DATA
-    )
-    assert result["type"] == RESULT_TYPE_CREATE_ENTRY
-    assert result["title"] == "fake_host"
-    assert result["data"][CONF_HOST] == "fake_host"
-    assert result["data"][CONF_PASSWORD] == "fake_pass"
-    assert result["data"][CONF_USERNAME] == "fake_user"
-    assert not result["result"].unique_id
-
-
 async def test_ssdp(hass: HomeAssistant, fritz: Mock):
     """Test starting a flow from discovery."""
     result = await hass.config_entries.flow.async_init(

tests/components/fritzbox/test_init.py

@@ -1,4 +1,6 @@
 """Tests for the AVM Fritz!Box integration."""
+from __future__ import annotations
+
 from unittest.mock import Mock, call, patch
 
 from pyfritzhome import LoginError
@@ -19,19 +21,18 @@ from homeassistant.const import (
     STATE_UNAVAILABLE,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.setup import async_setup_component
 
-from . import MOCK_CONFIG, FritzDeviceSwitchMock
+from . import MOCK_CONFIG, FritzDeviceSwitchMock, setup_config_entry
 
 from tests.common import MockConfigEntry
 
 
 async def test_setup(hass: HomeAssistant, fritz: Mock):
     """Test setup of integration."""
-    assert await async_setup_component(hass, FB_DOMAIN, MOCK_CONFIG)
+    assert await setup_config_entry(hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0])
-    await hass.async_block_till_done()
     entries = hass.config_entries.async_entries()
     assert entries
+    assert len(entries) == 1
     assert entries[0].data[CONF_HOST] == "fake_host"
     assert entries[0].data[CONF_PASSWORD] == "fake_pass"
     assert entries[0].data[CONF_USERNAME] == "fake_user"
@@ -41,23 +42,6 @@ async def test_setup(hass: HomeAssistant, fritz: Mock):
     ]
 
 
-async def test_setup_duplicate_config(hass: HomeAssistant, fritz: Mock, caplog):
-    """Test duplicate config of integration."""
-    DUPLICATE = {
-        FB_DOMAIN: {
-            CONF_DEVICES: [
-                MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
-                MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
-            ]
-        }
-    }
-    assert not await async_setup_component(hass, FB_DOMAIN, DUPLICATE)
-    await hass.async_block_till_done()
-    assert not hass.states.async_entity_ids()
-    assert not hass.states.async_all()
-    assert "duplicate host entries found" in caplog.text
-
-
 async def test_coordinator_update_after_reboot(hass: HomeAssistant, fritz: Mock):
     """Test coordinator after reboot."""
     entry = MockConfigEntry(
@@ -107,7 +91,7 @@ async def test_unload_remove(hass: HomeAssistant, fritz: Mock):
     assert len(config_entries) == 1
     assert entry is config_entries[0]
 
-    assert await async_setup_component(hass, FB_DOMAIN, {}) is True
+    assert await hass.config_entries.async_setup(entry.entry_id)
     await hass.async_block_till_done()
 
     assert entry.state == ENTRY_STATE_LOADED
@@ -130,7 +114,7 @@ async def test_unload_remove(hass: HomeAssistant, fritz: Mock):
     assert state is None
 
 
-async def test_raise_config_entry_not_ready_when_offline(hass):
+async def test_raise_config_entry_not_ready_when_offline(hass: HomeAssistant):
     """Config entry state is ENTRY_STATE_SETUP_RETRY when fritzbox is offline."""
     entry = MockConfigEntry(
         domain=FB_DOMAIN,

tests/components/fritzbox/test_sensor.py

@@ -13,34 +13,28 @@ from homeassistant.components.sensor import DOMAIN
 from homeassistant.const import (
     ATTR_FRIENDLY_NAME,
     ATTR_UNIT_OF_MEASUREMENT,
+    CONF_DEVICES,
     PERCENTAGE,
     TEMP_CELSIUS,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.setup import async_setup_component
 import homeassistant.util.dt as dt_util
 
-from . import MOCK_CONFIG, FritzDeviceSensorMock
+from . import MOCK_CONFIG, FritzDeviceSensorMock, setup_config_entry
 
 from tests.common import async_fire_time_changed
 
 ENTITY_ID = f"{DOMAIN}.fake_name"
 
 
-async def setup_fritzbox(hass: HomeAssistant, config: dict):
-    """Set up mock AVM Fritz!Box."""
-    assert await async_setup_component(hass, FB_DOMAIN, config)
-    await hass.async_block_till_done()
-
-
 async def test_setup(hass: HomeAssistant, fritz: Mock):
     """Test setup of platform."""
     device = FritzDeviceSensorMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
-
     assert state
     assert state.state == "1.23"
     assert state.attributes[ATTR_FRIENDLY_NAME] == "fake_name"
@@ -49,7 +43,6 @@ async def test_setup(hass: HomeAssistant, fritz: Mock):
     assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == TEMP_CELSIUS
 
     state = hass.states.get(f"{ENTITY_ID}_battery")
-
     assert state
     assert state.state == "23"
     assert state.attributes[ATTR_FRIENDLY_NAME] == "fake_name Battery"
@@ -59,9 +52,9 @@ async def test_setup(hass: HomeAssistant, fritz: Mock):
 async def test_update(hass: HomeAssistant, fritz: Mock):
     """Test update without error."""
     device = FritzDeviceSensorMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
     assert device.update.call_count == 1
     assert fritz().login.call_count == 1
 
@@ -77,9 +70,9 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock):
     """Test update with error."""
     device = FritzDeviceSensorMock()
     device.update.side_effect = HTTPError("Boom")
-    fritz().get_devices.return_value = [device]
+    assert not await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
     assert device.update.call_count == 1
     assert fritz().login.call_count == 1
 

tests/components/fritzbox/test_switch.py

@@ -17,6 +17,7 @@ from homeassistant.const import (
     ATTR_ENTITY_ID,
     ATTR_FRIENDLY_NAME,
     ATTR_TEMPERATURE,
+    CONF_DEVICES,
     ENERGY_KILO_WATT_HOUR,
     SERVICE_TURN_OFF,
     SERVICE_TURN_ON,
@@ -24,30 +25,23 @@ from homeassistant.const import (
     TEMP_CELSIUS,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.setup import async_setup_component
 import homeassistant.util.dt as dt_util
 
-from . import MOCK_CONFIG, FritzDeviceSwitchMock
+from . import MOCK_CONFIG, FritzDeviceSwitchMock, setup_config_entry
 
 from tests.common import async_fire_time_changed
 
 ENTITY_ID = f"{DOMAIN}.fake_name"
 
 
-async def setup_fritzbox(hass: HomeAssistant, config: dict):
-    """Set up mock AVM Fritz!Box."""
-    assert await async_setup_component(hass, FB_DOMAIN, config)
-    await hass.async_block_till_done()
-
-
 async def test_setup(hass: HomeAssistant, fritz: Mock):
     """Test setup of platform."""
     device = FritzDeviceSwitchMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+    )
 
-    await setup_fritzbox(hass, MOCK_CONFIG)
     state = hass.states.get(ENTITY_ID)
-
     assert state
     assert state.state == STATE_ON
     assert state.attributes[ATTR_CURRENT_POWER_W] == 5.678
@@ -63,9 +57,9 @@ async def test_setup(hass: HomeAssistant, fritz: Mock):
 async def test_turn_on(hass: HomeAssistant, fritz: Mock):
     """Test turn device on."""
     device = FritzDeviceSwitchMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: ENTITY_ID}, True
@@ -76,9 +70,9 @@ async def test_turn_on(hass: HomeAssistant, fritz: Mock):
 async def test_turn_off(hass: HomeAssistant, fritz: Mock):
     """Test turn device off."""
     device = FritzDeviceSwitchMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
 
     assert await hass.services.async_call(
         DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: ENTITY_ID}, True
@@ -89,9 +83,9 @@ async def test_turn_off(hass: HomeAssistant, fritz: Mock):
 async def test_update(hass: HomeAssistant, fritz: Mock):
     """Test update without error."""
     device = FritzDeviceSwitchMock()
-    fritz().get_devices.return_value = [device]
+    assert await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
     assert device.update.call_count == 1
     assert fritz().login.call_count == 1
 
@@ -107,9 +101,9 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock):
     """Test update with error."""
     device = FritzDeviceSwitchMock()
     device.update.side_effect = HTTPError("Boom")
-    fritz().get_devices.return_value = [device]
+    assert not await setup_config_entry(
-
+        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
-    await setup_fritzbox(hass, MOCK_CONFIG)
+    )
     assert device.update.call_count == 1
     assert fritz().login.call_count == 1