fix

homeassistant/components/scrape/__init__.py

@@ -4,27 +4,40 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Coroutine
+from copy import deepcopy
 from datetime import timedelta
+import logging
+from types import MappingProxyType
 from typing import Any
 
 import voluptuous as vol
 
 from homeassistant.components.rest import RESOURCE_SCHEMA, create_rest_data_from_config
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
-from homeassistant.config_entries import ConfigEntry
+from homeassistant.components.sensor import CONF_STATE_CLASS, DOMAIN as SENSOR_DOMAIN
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
 from homeassistant.const import (
     CONF_ATTRIBUTE,
+    CONF_AUTHENTICATION,
+    CONF_DEVICE_CLASS,
+    CONF_HEADERS,
+    CONF_NAME,
+    CONF_PASSWORD,
     CONF_SCAN_INTERVAL,
+    CONF_TIMEOUT,
+    CONF_UNIQUE_ID,
+    CONF_UNIT_OF_MEASUREMENT,
+    CONF_USERNAME,
     CONF_VALUE_TEMPLATE,
+    CONF_VERIFY_SSL,
     Platform,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import (
     config_validation as cv,
+    device_registry as dr,
     discovery,
     entity_registry as er,
 )
-from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.trigger_template_entity import (
     CONF_AVAILABILITY,
     TEMPLATE_SENSOR_BASE_SCHEMA,
@@ -32,11 +45,22 @@ from homeassistant.helpers.trigger_template_entity import (
 )
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_INDEX, CONF_SELECT, DEFAULT_SCAN_INTERVAL, DOMAIN, PLATFORMS
+from .const import (
+    CONF_ADVANCED,
+    CONF_AUTH,
+    CONF_ENCODING,
+    CONF_INDEX,
+    CONF_SELECT,
+    DEFAULT_SCAN_INTERVAL,
+    DOMAIN,
+    PLATFORMS,
+)
 from .coordinator import ScrapeCoordinator
 
 type ScrapeConfigEntry = ConfigEntry[ScrapeCoordinator]
 
+_LOGGER = logging.getLogger(__name__)
+
 SENSOR_SCHEMA = vol.Schema(
     {
         **TEMPLATE_SENSOR_BASE_SCHEMA.schema,
@@ -103,7 +127,13 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 async def async_setup_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bool:
     """Set up Scrape from a config entry."""
 
-    rest_config: dict[str, Any] = COMBINED_SCHEMA(dict(entry.options))
+    config: dict[str, Any] = dict(entry.options)
+    # Config flow uses sections but the COMBINED SCHEMA does not
+    # so we need to flatten the config here
+    config.update(config.pop(CONF_ADVANCED, {}))
+    config.update(config.pop(CONF_AUTH, {}))
+
+    rest_config: dict[str, Any] = COMBINED_SCHEMA(dict(config))
     rest = create_rest_data_from_config(hass, rest_config)
 
     coordinator = ScrapeCoordinator(
@@ -117,17 +147,162 @@ async def async_setup_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bo
     entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    entry.async_on_unload(entry.add_update_listener(update_listener))
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_migrate_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bool:
+    """Migrate old entry."""
+
+    if entry.version > 2:
+        # Don't migrate from future version
+        return False
+
+    if entry.version == 1:
+        old_to_new_sensor_id = {}
+        for sensor_config in entry.options[SENSOR_DOMAIN]:
+            # Create a new sub config entry per sensor
+            title = sensor_config.pop(CONF_NAME)
+            old_unique_id = sensor_config[CONF_UNIQUE_ID]
+            subentry_config = {
+                CONF_INDEX: sensor_config[CONF_INDEX],
+                CONF_SELECT: sensor_config[CONF_SELECT],
+                CONF_ADVANCED: {},
+            }
+
+            for sensor_advanced_key in (
+                CONF_ATTRIBUTE,
+                CONF_VALUE_TEMPLATE,
+                CONF_AVAILABILITY,
+                CONF_DEVICE_CLASS,
+                CONF_STATE_CLASS,
+                CONF_UNIT_OF_MEASUREMENT,
+            ):
+                if sensor_advanced_key not in sensor_config:
+                    continue
+                subentry_config[CONF_ADVANCED][sensor_advanced_key] = sensor_config[
+                    sensor_advanced_key
+                ]
+
+            new_sub_entry = ConfigSubentry(
+                data=MappingProxyType(subentry_config),
+                subentry_type="entity",
+                title=title,
+                unique_id=None,
+            )
+            _LOGGER.debug(
+                "Migrating sensor %s with unique id %s to sub config entry id %s, data %s",
+                title,
+                old_unique_id,
+                new_sub_entry.subentry_id,
+                sensor_config,
+            )
+            old_to_new_sensor_id[old_unique_id] = new_sub_entry.subentry_id
+            hass.config_entries.async_add_subentry(entry, new_sub_entry)
+
+        # Use the new sub config entry id as the unique id for the sensor entity
+        entity_reg = er.async_get(hass)
+        entities = er.async_entries_for_config_entry(entity_reg, entry.entry_id)
+        for entity in entities:
+            if (old_unique_id := entity.unique_id) in old_to_new_sensor_id:
+                new_unique_id = old_to_new_sensor_id[old_unique_id]
+                _LOGGER.debug(
+                    "Migrating entity %s with unique id %s to new unique id %s",
+                    entity.entity_id,
+                    entity.unique_id,
+                    new_unique_id,
+                )
+                entity_reg.async_update_entity(
+                    entity.entity_id,
+                    config_entry_id=entry.entry_id,
+                    config_subentry_id=new_unique_id,
+                    new_unique_id=new_unique_id,
+                )
+
+        # Use the new sub config entry id as the identifier for the sensor device
+        device_reg = dr.async_get(hass)
+        devices = dr.async_entries_for_config_entry(device_reg, entry.entry_id)
+        for device in devices:
+            for domain, identifier in device.identifiers:
+                if domain != DOMAIN or identifier not in old_to_new_sensor_id:
+                    continue
+                if identifier in old_to_new_sensor_id:
+                    subentry_id = old_to_new_sensor_id[identifier]
+                    new_identifiers = deepcopy(device.identifiers)
+                    new_identifiers.remove((domain, identifier))
+                    new_identifiers.add((domain, old_to_new_sensor_id[identifier]))
+                    _LOGGER.debug(
+                        "Migrating device %s with identifiers %s to new identifiers %s",
+                        device.id,
+                        device.identifiers,
+                        new_identifiers,
+                    )
+                    device_reg.async_update_device(
+                        device.id,
+                        add_config_entry_id=entry.entry_id,
+                        add_config_subentry_id=subentry_id,
+                        new_identifiers=new_identifiers,
+                    )
+                    if (
+                        sub_entries := device.config_entries_subentries.get(
+                            entry.entry_id
+                        )
+                    ) and None in sub_entries:
+                        # Removing None from the list of subentries
+                        # as the device should only belong to the subentry
+                        # and not the main config entry
+                        device_reg.async_update_device(
+                            device.id,
+                            remove_config_entry_id=entry.entry_id,
+                            remove_config_subentry_id=None,
+                        )
+
+        # Update the resource config
+        new_config_entry_data = dict(entry.options)
+        new_config_entry_data[CONF_AUTH] = {}
+        new_config_entry_data[CONF_ADVANCED] = {}
+        new_config_entry_data.pop(SENSOR_DOMAIN, None)
+        for resource_advanced_key in (
+            CONF_HEADERS,
+            CONF_VERIFY_SSL,
+            CONF_TIMEOUT,
+            CONF_ENCODING,
+        ):
+            if resource_advanced_key in new_config_entry_data:
+                new_config_entry_data[CONF_ADVANCED][resource_advanced_key] = (
+                    new_config_entry_data.pop(resource_advanced_key)
+                )
+        for resource_auth_key in (CONF_AUTHENTICATION, CONF_USERNAME, CONF_PASSWORD):
+            if resource_auth_key in new_config_entry_data:
+                new_config_entry_data[CONF_AUTH][resource_auth_key] = (
+                    new_config_entry_data.pop(resource_auth_key)
+                )
+
+        _LOGGER.debug(
+            "Migrating config entry %s from version 1 to version 2 with data %s",
+            entry.entry_id,
+            new_config_entry_data,
+        )
+        hass.config_entries.async_update_entry(
+            entry, version=2, options=new_config_entry_data
+        )
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bool:
     """Unload Scrape config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
+async def update_listener(hass: HomeAssistant, entry: ScrapeConfigEntry) -> None:
+    """Handle config entry update."""
+    hass.config_entries.async_schedule_reload(entry.entry_id)
+
+
 async def async_remove_config_entry_device(
-    hass: HomeAssistant, entry: ConfigEntry, device: DeviceEntry
+    hass: HomeAssistant, entry: ConfigEntry, device: dr.DeviceEntry
 ) -> bool:
     """Remove Scrape config entry from a device."""
     entity_registry = er.async_get(hass)

homeassistant/components/scrape/config_flow.py

@@ -2,12 +2,13 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
-from typing import Any, cast
-import uuid
+from copy import deepcopy
+import logging
+from typing import Any
 
 import voluptuous as vol
 
+from homeassistant import data_entry_flow
 from homeassistant.components.rest import create_rest_data_from_config
 from homeassistant.components.rest.data import (  # pylint: disable=hass-component-root-import
     DEFAULT_TIMEOUT,
@@ -18,10 +19,17 @@ from homeassistant.components.rest.schema import (  # pylint: disable=hass-compo
 )
 from homeassistant.components.sensor import (
     CONF_STATE_CLASS,
-    DOMAIN as SENSOR_DOMAIN,
     SensorDeviceClass,
     SensorStateClass,
 )
+from homeassistant.config_entries import (
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    ConfigSubentryFlow,
+    OptionsFlow,
+    SubentryFlowResult,
+)
 from homeassistant.const import (
     CONF_ATTRIBUTE,
     CONF_AUTHENTICATION,
@@ -33,7 +41,6 @@ from homeassistant.const import (
     CONF_PAYLOAD,
     CONF_RESOURCE,
     CONF_TIMEOUT,
-    CONF_UNIQUE_ID,
     CONF_UNIT_OF_MEASUREMENT,
     CONF_USERNAME,
     CONF_VALUE_TEMPLATE,
@@ -42,15 +49,7 @@ from homeassistant.const import (
     HTTP_DIGEST_AUTHENTICATION,
     UnitOfTemperature,
 )
-from homeassistant.core import async_get_hass
-from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.schema_config_entry_flow import (
-    SchemaCommonFlowHandler,
-    SchemaConfigFlowHandler,
-    SchemaFlowError,
-    SchemaFlowFormStep,
-    SchemaFlowMenuStep,
-)
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.selector import (
     BooleanSelector,
     NumberSelector,
@@ -69,6 +68,8 @@ from homeassistant.helpers.trigger_template_entity import CONF_AVAILABILITY
 
 from . import COMBINED_SCHEMA
 from .const import (
+    CONF_ADVANCED,
+    CONF_AUTH,
     CONF_ENCODING,
     CONF_INDEX,
     CONF_SELECT,
@@ -78,243 +79,212 @@ from .const import (
     DOMAIN,
 )
 
-RESOURCE_SETUP = {
-    vol.Required(CONF_RESOURCE): TextSelector(
-        TextSelectorConfig(type=TextSelectorType.URL)
-    ),
-    vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): SelectSelector(
-        SelectSelectorConfig(options=METHODS, mode=SelectSelectorMode.DROPDOWN)
-    ),
-    vol.Optional(CONF_PAYLOAD): ObjectSelector(),
-    vol.Optional(CONF_AUTHENTICATION): SelectSelector(
-        SelectSelectorConfig(
-            options=[HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION],
-            mode=SelectSelectorMode.DROPDOWN,
-        )
-    ),
-    vol.Optional(CONF_USERNAME): TextSelector(),
-    vol.Optional(CONF_PASSWORD): TextSelector(
-        TextSelectorConfig(type=TextSelectorType.PASSWORD)
-    ),
-    vol.Optional(CONF_HEADERS): ObjectSelector(),
-    vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): BooleanSelector(),
-    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): NumberSelector(
-        NumberSelectorConfig(min=0, step=1, mode=NumberSelectorMode.BOX)
-    ),
-    vol.Optional(CONF_ENCODING, default=DEFAULT_ENCODING): TextSelector(),
-}
+_LOGGER = logging.getLogger(__name__)
 
-SENSOR_SETUP = {
-    vol.Required(CONF_SELECT): TextSelector(),
-    vol.Optional(CONF_INDEX, default=0): NumberSelector(
-        NumberSelectorConfig(min=0, step=1, mode=NumberSelectorMode.BOX)
-    ),
-    vol.Optional(CONF_ATTRIBUTE): TextSelector(),
-    vol.Optional(CONF_VALUE_TEMPLATE): TemplateSelector(),
-    vol.Optional(CONF_AVAILABILITY): TemplateSelector(),
-    vol.Optional(CONF_DEVICE_CLASS): SelectSelector(
-        SelectSelectorConfig(
-            options=[
-                cls.value for cls in SensorDeviceClass if cls != SensorDeviceClass.ENUM
-            ],
-            mode=SelectSelectorMode.DROPDOWN,
-            translation_key="device_class",
-            sort=True,
-        )
-    ),
-    vol.Optional(CONF_STATE_CLASS): SelectSelector(
-        SelectSelectorConfig(
-            options=[cls.value for cls in SensorStateClass],
-            mode=SelectSelectorMode.DROPDOWN,
-            translation_key="state_class",
-            sort=True,
-        )
-    ),
-    vol.Optional(CONF_UNIT_OF_MEASUREMENT): SelectSelector(
-        SelectSelectorConfig(
-            options=[cls.value for cls in UnitOfTemperature],
-            custom_value=True,
-            mode=SelectSelectorMode.DROPDOWN,
-            translation_key="unit_of_measurement",
-            sort=True,
-        )
-    ),
-}
-
-
-async def validate_rest_setup(
-    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
-) -> dict[str, Any]:
-    """Validate rest setup."""
-    hass = async_get_hass()
-    rest_config: dict[str, Any] = COMBINED_SCHEMA(user_input)
-    try:
-        rest = create_rest_data_from_config(hass, rest_config)
-        await rest.async_update()
-    except Exception as err:
-        raise SchemaFlowError("resource_error") from err
-    if rest.data is None:
-        raise SchemaFlowError("resource_error")
-    return user_input
-
-
-async def validate_sensor_setup(
-    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
-) -> dict[str, Any]:
-    """Validate sensor input."""
-    user_input[CONF_INDEX] = int(user_input[CONF_INDEX])
-    user_input[CONF_UNIQUE_ID] = str(uuid.uuid1())
-
-    # Standard behavior is to merge the result with the options.
-    # In this case, we want to add a sub-item so we update the options directly.
-    sensors: list[dict[str, Any]] = handler.options.setdefault(SENSOR_DOMAIN, [])
-    sensors.append(user_input)
-    return {}
-
-
-async def validate_select_sensor(
-    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
-) -> dict[str, Any]:
-    """Store sensor index in flow state."""
-    handler.flow_state["_idx"] = int(user_input[CONF_INDEX])
-    return {}
-
-
-async def get_select_sensor_schema(handler: SchemaCommonFlowHandler) -> vol.Schema:
-    """Return schema for selecting a sensor."""
-    return vol.Schema(
-        {
-            vol.Required(CONF_INDEX): vol.In(
-                {
-                    str(index): config[CONF_NAME]
-                    for index, config in enumerate(handler.options[SENSOR_DOMAIN])
-                },
-            )
-        }
-    )
-
-
-async def get_edit_sensor_suggested_values(
-    handler: SchemaCommonFlowHandler,
-) -> dict[str, Any]:
-    """Return suggested values for sensor editing."""
-    idx: int = handler.flow_state["_idx"]
-    return dict(handler.options[SENSOR_DOMAIN][idx])
-
-
-async def validate_sensor_edit(
-    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
-) -> dict[str, Any]:
-    """Update edited sensor."""
-    user_input[CONF_INDEX] = int(user_input[CONF_INDEX])
-
-    # Standard behavior is to merge the result with the options.
-    # In this case, we want to add a sub-item so we update the options directly,
-    # including popping omitted optional schema items.
-    idx: int = handler.flow_state["_idx"]
-    handler.options[SENSOR_DOMAIN][idx].update(user_input)
-    for key in DATA_SCHEMA_EDIT_SENSOR.schema:
-        if isinstance(key, vol.Optional) and key not in user_input:
-            # Key not present, delete keys old value (if present) too
-            handler.options[SENSOR_DOMAIN][idx].pop(key, None)
-    return {}
-
-
-async def get_remove_sensor_schema(handler: SchemaCommonFlowHandler) -> vol.Schema:
-    """Return schema for sensor removal."""
-    return vol.Schema(
-        {
-            vol.Required(CONF_INDEX): cv.multi_select(
-                {
-                    str(index): config[CONF_NAME]
-                    for index, config in enumerate(handler.options[SENSOR_DOMAIN])
-                },
-            )
-        }
-    )
-
-
-async def validate_remove_sensor(
-    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
-) -> dict[str, Any]:
-    """Validate remove sensor."""
-    removed_indexes: set[str] = set(user_input[CONF_INDEX])
-
-    # Standard behavior is to merge the result with the options.
-    # In this case, we want to remove sub-items so we update the options directly.
-    entity_registry = er.async_get(handler.parent_handler.hass)
-    sensors: list[dict[str, Any]] = []
-    sensor: dict[str, Any]
-    for index, sensor in enumerate(handler.options[SENSOR_DOMAIN]):
-        if str(index) not in removed_indexes:
-            sensors.append(sensor)
-        elif entity_id := entity_registry.async_get_entity_id(
-            SENSOR_DOMAIN, DOMAIN, sensor[CONF_UNIQUE_ID]
-        ):
-            entity_registry.async_remove(entity_id)
-    handler.options[SENSOR_DOMAIN] = sensors
-    return {}
-
-
-DATA_SCHEMA_RESOURCE = vol.Schema(RESOURCE_SETUP)
-DATA_SCHEMA_EDIT_SENSOR = vol.Schema(SENSOR_SETUP)
-DATA_SCHEMA_SENSOR = vol.Schema(
+RESOURCE_SETUP = vol.Schema(
     {
-        vol.Optional(CONF_NAME, default=DEFAULT_NAME): TextSelector(),
-        **SENSOR_SETUP,
+        vol.Required(CONF_RESOURCE): TextSelector(
+            TextSelectorConfig(type=TextSelectorType.URL)
+        ),
+        vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): SelectSelector(
+            SelectSelectorConfig(options=METHODS, mode=SelectSelectorMode.DROPDOWN)
+        ),
+        vol.Optional(CONF_PAYLOAD): ObjectSelector(),
+        vol.Required(CONF_AUTH): data_entry_flow.section(
+            vol.Schema(
+                {
+                    vol.Optional(CONF_AUTHENTICATION): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[
+                                HTTP_BASIC_AUTHENTICATION,
+                                HTTP_DIGEST_AUTHENTICATION,
+                            ],
+                            mode=SelectSelectorMode.DROPDOWN,
+                        )
+                    ),
+                    vol.Optional(CONF_USERNAME): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.TEXT, autocomplete="username"
+                        )
+                    ),
+                    vol.Optional(CONF_PASSWORD): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.PASSWORD,
+                            autocomplete="current-password",
+                        )
+                    ),
+                }
+            ),
+            data_entry_flow.SectionConfig(collapsed=True),
+        ),
+        vol.Required(CONF_ADVANCED): data_entry_flow.section(
+            vol.Schema(
+                {
+                    vol.Optional(CONF_HEADERS): ObjectSelector(),
+                    vol.Optional(
+                        CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL
+                    ): BooleanSelector(),
+                    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): NumberSelector(
+                        NumberSelectorConfig(min=0, step=1, mode=NumberSelectorMode.BOX)
+                    ),
+                    vol.Optional(
+                        CONF_ENCODING, default=DEFAULT_ENCODING
+                    ): TextSelector(),
+                }
+            ),
+            data_entry_flow.SectionConfig(collapsed=True),
+        ),
     }
 )
 
-CONFIG_FLOW = {
-    "user": SchemaFlowFormStep(
-        schema=DATA_SCHEMA_RESOURCE,
-        next_step="sensor",
-        validate_user_input=validate_rest_setup,
-    ),
-    "sensor": SchemaFlowFormStep(
-        schema=DATA_SCHEMA_SENSOR,
-        validate_user_input=validate_sensor_setup,
-    ),
-}
-OPTIONS_FLOW = {
-    "init": SchemaFlowMenuStep(
-        ["resource", "add_sensor", "select_edit_sensor", "remove_sensor"]
-    ),
-    "resource": SchemaFlowFormStep(
-        DATA_SCHEMA_RESOURCE,
-        validate_user_input=validate_rest_setup,
-    ),
-    "add_sensor": SchemaFlowFormStep(
-        DATA_SCHEMA_SENSOR,
-        suggested_values=None,
-        validate_user_input=validate_sensor_setup,
-    ),
-    "select_edit_sensor": SchemaFlowFormStep(
-        get_select_sensor_schema,
-        suggested_values=None,
-        validate_user_input=validate_select_sensor,
-        next_step="edit_sensor",
-    ),
-    "edit_sensor": SchemaFlowFormStep(
-        DATA_SCHEMA_EDIT_SENSOR,
-        suggested_values=get_edit_sensor_suggested_values,
-        validate_user_input=validate_sensor_edit,
-    ),
-    "remove_sensor": SchemaFlowFormStep(
-        get_remove_sensor_schema,
-        suggested_values=None,
-        validate_user_input=validate_remove_sensor,
-    ),
-}
+SENSOR_SETUP = vol.Schema(
+    {
+        vol.Optional(CONF_NAME, default=DEFAULT_NAME): TextSelector(),
+        vol.Required(CONF_SELECT): TextSelector(),
+        vol.Optional(CONF_INDEX, default=0): vol.All(
+            NumberSelector(
+                NumberSelectorConfig(min=0, step=1, mode=NumberSelectorMode.BOX)
+            ),
+            vol.Coerce(int),
+        ),
+        vol.Required(CONF_ADVANCED): data_entry_flow.section(
+            vol.Schema(
+                {
+                    vol.Optional(CONF_ATTRIBUTE): TextSelector(),
+                    vol.Optional(CONF_VALUE_TEMPLATE): TemplateSelector(),
+                    vol.Optional(CONF_AVAILABILITY): TemplateSelector(),
+                    vol.Optional(CONF_DEVICE_CLASS): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[
+                                cls.value
+                                for cls in SensorDeviceClass
+                                if cls != SensorDeviceClass.ENUM
+                            ],
+                            mode=SelectSelectorMode.DROPDOWN,
+                            translation_key="device_class",
+                            sort=True,
+                        )
+                    ),
+                    vol.Optional(CONF_STATE_CLASS): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[cls.value for cls in SensorStateClass],
+                            mode=SelectSelectorMode.DROPDOWN,
+                            translation_key="state_class",
+                            sort=True,
+                        )
+                    ),
+                    vol.Optional(CONF_UNIT_OF_MEASUREMENT): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[cls.value for cls in UnitOfTemperature],
+                            custom_value=True,
+                            mode=SelectSelectorMode.DROPDOWN,
+                            translation_key="unit_of_measurement",
+                            sort=True,
+                        )
+                    ),
+                }
+            ),
+            data_entry_flow.SectionConfig(collapsed=True),
+        ),
+    }
+)
 
 
-class ScrapeConfigFlowHandler(SchemaConfigFlowHandler, domain=DOMAIN):
-    """Handle a config flow for Scrape."""
+async def validate_rest_setup(
+    hass: HomeAssistant, user_input: dict[str, Any]
+) -> dict[str, Any]:
+    """Validate rest setup."""
+    config = deepcopy(user_input)
+    config.update(config.pop(CONF_ADVANCED, {}))
+    config.update(config.pop(CONF_AUTH, {}))
+    rest_config: dict[str, Any] = COMBINED_SCHEMA(config)
+    try:
+        rest = create_rest_data_from_config(hass, rest_config)
+        await rest.async_update()
+    except Exception:
+        _LOGGER.exception("Error when getting resource %s", config[CONF_RESOURCE])
+        return {"base": "resource_error"}
+    if rest.data is None:
+        return {"base": "no_data"}
+    return {}
 
-    config_flow = CONFIG_FLOW
-    options_flow = OPTIONS_FLOW
-    options_flow_reloads = True
 
-    def async_config_entry_title(self, options: Mapping[str, Any]) -> str:
-        """Return config entry title."""
-        return cast(str, options[CONF_RESOURCE])
+class ScrapeConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Scrape configuration flow."""
+
+    VERSION = 2
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: ConfigEntry) -> ScrapeOptionFlow:
+        """Get the options flow for this handler."""
+        return ScrapeOptionFlow()
+
+    @classmethod
+    @callback
+    def async_get_supported_subentry_types(
+        cls, config_entry: ConfigEntry
+    ) -> dict[str, type[ConfigSubentryFlow]]:
+        """Return subentries supported by this handler."""
+        return {"entity": ScrapeSubentryFlowHandler}
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """User flow to create the main config entry."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            errors = await validate_rest_setup(self.hass, user_input)
+            title = user_input[CONF_RESOURCE]
+            if not errors:
+                return self.async_create_entry(data={}, options=user_input, title=title)
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                RESOURCE_SETUP, user_input or {}
+            ),
+            errors=errors,
+        )
+
+
+class ScrapeOptionFlow(OptionsFlow):
+    """Scrape Options flow."""
+
+    async def async_step_init(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Manage Scrape options."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            errors = await validate_rest_setup(self.hass, user_input)
+            if not errors:
+                return self.async_create_entry(data=user_input)
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=self.add_suggested_values_to_schema(
+                RESOURCE_SETUP,
+                user_input or self.config_entry.options,
+            ),
+            errors=errors,
+        )
+
+
+class ScrapeSubentryFlowHandler(ConfigSubentryFlow):
+    """Handle subentry flow."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """User flow to create a sensor subentry."""
+        if user_input is not None:
+            title = user_input.pop("name")
+            return self.async_create_entry(data=user_input, title=title)
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                SENSOR_SETUP, user_input or {}
+            ),
+        )

homeassistant/components/scrape/const.py

@@ -14,6 +14,8 @@ DEFAULT_SCAN_INTERVAL = timedelta(minutes=10)
 
 PLATFORMS = [Platform.SENSOR]
 
+CONF_ADVANCED = "advanced"
+CONF_AUTH = "auth"
 CONF_ENCODING = "encoding"
 CONF_SELECT = "select"
 CONF_INDEX = "index"

homeassistant/components/scrape/icons.json

@@ -0,0 +1,21 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "sections": {
+          "advanced": "mdi:cog",
+          "auth": "mdi:lock"
+        }
+      }
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "sections": {
+          "advanced": "mdi:cog"
+        }
+      }
+    }
+  }
+}

homeassistant/components/scrape/sensor.py

@@ -46,9 +46,10 @@ TRIGGER_ENTITY_OPTIONS = (
     CONF_AVAILABILITY,
     CONF_DEVICE_CLASS,
     CONF_ICON,
+    CONF_NAME,
     CONF_PICTURE,
-    CONF_UNIQUE_ID,
     CONF_STATE_CLASS,
+    CONF_UNIQUE_ID,
     CONF_UNIT_OF_MEASUREMENT,
 )
 
@@ -70,7 +71,7 @@ async def async_setup_platform(
 
     entities: list[ScrapeSensor] = []
     for sensor_config in sensors_config:
-        trigger_entity_config = {CONF_NAME: sensor_config[CONF_NAME]}
+        trigger_entity_config = {}
         for key in TRIGGER_ENTITY_OPTIONS:
             if key not in sensor_config:
                 continue
@@ -98,23 +99,24 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Scrape sensor entry."""
-    entities: list = []
-
     coordinator = entry.runtime_data
-    config = dict(entry.options)
-    for sensor in config["sensor"]:
+    for subentry in entry.subentries.values():
+        sensor = dict(subentry.data)
+        sensor.update(sensor.pop("advanced", {}))
+        sensor[CONF_UNIQUE_ID] = subentry.subentry_id
+        sensor[CONF_NAME] = subentry.title
+
         sensor_config: ConfigType = vol.Schema(
             TEMPLATE_SENSOR_BASE_SCHEMA.schema, extra=vol.ALLOW_EXTRA
         )(sensor)
 
-        name: str = sensor_config[CONF_NAME]
         value_string: str | None = sensor_config.get(CONF_VALUE_TEMPLATE)
 
         value_template: ValueTemplate | None = (
             ValueTemplate(value_string, hass) if value_string is not None else None
         )
 
-        trigger_entity_config: dict[str, str | Template | None] = {CONF_NAME: name}
+        trigger_entity_config: dict[str, str | Template | None] = {}
         for key in TRIGGER_ENTITY_OPTIONS:
             if key not in sensor_config:
                 continue
@@ -123,21 +125,22 @@ async def async_setup_entry(
                 continue
             trigger_entity_config[key] = sensor_config[key]
 
-        entities.append(
-            ScrapeSensor(
-                hass,
-                coordinator,
-                trigger_entity_config,
-                sensor_config[CONF_SELECT],
-                sensor_config.get(CONF_ATTRIBUTE),
-                sensor_config[CONF_INDEX],
-                value_template,
-                False,
-            )
+        async_add_entities(
+            [
+                ScrapeSensor(
+                    hass,
+                    coordinator,
+                    trigger_entity_config,
+                    sensor_config[CONF_SELECT],
+                    sensor_config.get(CONF_ATTRIBUTE),
+                    sensor_config[CONF_INDEX],
+                    value_template,
+                    False,
+                )
+            ],
+            config_subentry_id=subentry.subentry_id,
         )
 
-    async_add_entities(entities)
-
 
 class ScrapeSensor(CoordinatorEntity[ScrapeCoordinator], ManualTriggerSensorEntity):
     """Representation of a web scrape sensor."""

homeassistant/components/scrape/strings.json

@@ -4,134 +4,136 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
     },
     "error": {
+      "no_data": "Rest data is empty. Verify your configuration",
       "resource_error": "Could not update rest data. Verify your configuration"
     },
     "step": {
-      "sensor": {
-        "data": {
-          "attribute": "Attribute",
-          "availability": "Availability template",
-          "device_class": "Device class",
-          "index": "Index",
-          "name": "[%key:common::config_flow::data::name%]",
-          "select": "Select",
-          "state_class": "State class",
-          "unit_of_measurement": "Unit of measurement",
-          "value_template": "Value template"
-        },
-        "data_description": {
-          "attribute": "Get value of an attribute on the selected tag.",
-          "availability": "Defines a template to get the availability of the sensor.",
-          "device_class": "The type/class of the sensor to set the icon in the frontend.",
-          "index": "Defines which of the elements returned by the CSS selector to use.",
-          "select": "Defines what tag to search for. Check Beautifulsoup CSS selectors for details.",
-          "state_class": "The state_class of the sensor.",
-          "unit_of_measurement": "Choose unit of measurement or create your own.",
-          "value_template": "Defines a template to get the state of the sensor."
-        }
-      },
       "user": {
         "data": {
-          "authentication": "Select authentication method",
-          "encoding": "Character encoding",
-          "headers": "Headers",
           "method": "Method",
-          "password": "[%key:common::config_flow::data::password%]",
           "payload": "Payload",
-          "resource": "Resource",
-          "timeout": "Timeout",
-          "username": "[%key:common::config_flow::data::username%]",
-          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+          "resource": "Resource"
         },
         "data_description": {
-          "authentication": "Type of the HTTP authentication. Either basic or digest.",
-          "encoding": "Character encoding to use. Defaults to UTF-8.",
-          "headers": "Headers to use for the web request.",
           "payload": "Payload to use when method is POST.",
-          "resource": "The URL to the website that contains the value.",
-          "timeout": "Timeout for connection to website.",
-          "verify_ssl": "Enables/disables verification of SSL/TLS certificate, for example if it is self-signed."
+          "resource": "The URL to the website that contains the value."
+        },
+        "sections": {
+          "advanced": {
+            "data": {
+              "encoding": "Character encoding",
+              "headers": "Headers",
+              "timeout": "Timeout",
+              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+            },
+            "data_description": {
+              "encoding": "Character encoding to use. Defaults to UTF-8.",
+              "headers": "Headers to use for the web request.",
+              "timeout": "Timeout for connection to website.",
+              "verify_ssl": "Enables/disables verification of SSL/TLS certificate, for example if it is self-signed."
+            },
+            "description": "Provide additional advanced settings for the resource.",
+            "name": "Advanced settings"
+          },
+          "auth": {
+            "data": {
+              "authentication": "Select authentication method",
+              "password": "[%key:common::config_flow::data::password%]",
+              "username": "[%key:common::config_flow::data::username%]"
+            },
+            "data_description": {
+              "authentication": "Type of the HTTP authentication. Either basic or digest."
+            },
+            "description": "Provide authentication details to access the resource.",
+            "name": "Authentication settings"
+          }
+        }
+      }
+    }
+  },
+  "config_subentries": {
+    "entity": {
+      "step": {
+        "user": {
+          "data": {
+            "index": "Index",
+            "select": "Select"
+          },
+          "data_description": {
+            "index": "Defines which of the elements returned by the CSS selector to use.",
+            "select": "Defines what tag to search for. Check Beautifulsoup CSS selectors for details."
+          },
+          "sections": {
+            "advanced": {
+              "data": {
+                "attribute": "Attribute",
+                "availability": "Availability template",
+                "device_class": "Device class",
+                "state_class": "State class",
+                "unit_of_measurement": "Unit of measurement",
+                "value_template": "Value template"
+              },
+              "data_description": {
+                "attribute": "Get value of an attribute on the selected tag.",
+                "availability": "Defines a template to get the availability of the sensor.",
+                "device_class": "The type/class of the sensor to set the icon in the frontend.",
+                "state_class": "The state_class of the sensor.",
+                "unit_of_measurement": "Choose unit of measurement or create your own.",
+                "value_template": "Defines a template to get the state of the sensor."
+              },
+              "description": "Provide additional advanced settings for the sensor.",
+              "name": "Advanced settings"
+            }
+          }
         }
       }
     }
   },
   "options": {
+    "error": {
+      "no_data": "[%key:component::scrape::config::error::no_data%]",
+      "resource_error": "[%key:component::scrape::config::error::resource_error%]"
+    },
     "step": {
-      "add_sensor": {
-        "data": {
-          "attribute": "[%key:component::scrape::config::step::sensor::data::attribute%]",
-          "availability": "[%key:component::scrape::config::step::sensor::data::availability%]",
-          "device_class": "[%key:component::scrape::config::step::sensor::data::device_class%]",
-          "index": "[%key:component::scrape::config::step::sensor::data::index%]",
-          "name": "[%key:common::config_flow::data::name%]",
-          "select": "[%key:component::scrape::config::step::sensor::data::select%]",
-          "state_class": "[%key:component::scrape::config::step::sensor::data::state_class%]",
-          "unit_of_measurement": "[%key:component::scrape::config::step::sensor::data::unit_of_measurement%]",
-          "value_template": "[%key:component::scrape::config::step::sensor::data::value_template%]"
-        },
-        "data_description": {
-          "attribute": "[%key:component::scrape::config::step::sensor::data_description::attribute%]",
-          "availability": "[%key:component::scrape::config::step::sensor::data_description::availability%]",
-          "device_class": "[%key:component::scrape::config::step::sensor::data_description::device_class%]",
-          "index": "[%key:component::scrape::config::step::sensor::data_description::index%]",
-          "select": "[%key:component::scrape::config::step::sensor::data_description::select%]",
-          "state_class": "[%key:component::scrape::config::step::sensor::data_description::state_class%]",
-          "unit_of_measurement": "[%key:component::scrape::config::step::sensor::data_description::unit_of_measurement%]",
-          "value_template": "[%key:component::scrape::config::step::sensor::data_description::value_template%]"
-        }
-      },
-      "edit_sensor": {
-        "data": {
-          "attribute": "[%key:component::scrape::config::step::sensor::data::attribute%]",
-          "availability": "[%key:component::scrape::config::step::sensor::data::availability%]",
-          "device_class": "[%key:component::scrape::config::step::sensor::data::device_class%]",
-          "index": "[%key:component::scrape::config::step::sensor::data::index%]",
-          "name": "[%key:common::config_flow::data::name%]",
-          "select": "[%key:component::scrape::config::step::sensor::data::select%]",
-          "state_class": "[%key:component::scrape::config::step::sensor::data::state_class%]",
-          "unit_of_measurement": "[%key:component::scrape::config::step::sensor::data::unit_of_measurement%]",
-          "value_template": "[%key:component::scrape::config::step::sensor::data::value_template%]"
-        },
-        "data_description": {
-          "attribute": "[%key:component::scrape::config::step::sensor::data_description::attribute%]",
-          "availability": "[%key:component::scrape::config::step::sensor::data_description::availability%]",
-          "device_class": "[%key:component::scrape::config::step::sensor::data_description::device_class%]",
-          "index": "[%key:component::scrape::config::step::sensor::data_description::index%]",
-          "select": "[%key:component::scrape::config::step::sensor::data_description::select%]",
-          "state_class": "[%key:component::scrape::config::step::sensor::data_description::state_class%]",
-          "unit_of_measurement": "[%key:component::scrape::config::step::sensor::data_description::unit_of_measurement%]",
-          "value_template": "[%key:component::scrape::config::step::sensor::data_description::value_template%]"
-        }
-      },
       "init": {
-        "menu_options": {
-          "add_sensor": "Add sensor",
-          "remove_sensor": "Remove sensor",
-          "resource": "Configure resource",
-          "select_edit_sensor": "Configure sensor"
-        }
-      },
-      "resource": {
         "data": {
-          "authentication": "[%key:component::scrape::config::step::user::data::authentication%]",
-          "encoding": "[%key:component::scrape::config::step::user::data::encoding%]",
-          "headers": "[%key:component::scrape::config::step::user::data::headers%]",
           "method": "[%key:component::scrape::config::step::user::data::method%]",
-          "password": "[%key:common::config_flow::data::password%]",
           "payload": "[%key:component::scrape::config::step::user::data::payload%]",
-          "resource": "[%key:component::scrape::config::step::user::data::resource%]",
-          "timeout": "[%key:component::scrape::config::step::user::data::timeout%]",
-          "username": "[%key:common::config_flow::data::username%]",
-          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+          "resource": "[%key:component::scrape::config::step::user::data::resource%]"
         },
         "data_description": {
-          "authentication": "[%key:component::scrape::config::step::user::data_description::authentication%]",
-          "encoding": "[%key:component::scrape::config::step::user::data_description::encoding%]",
-          "headers": "[%key:component::scrape::config::step::user::data_description::headers%]",
           "payload": "[%key:component::scrape::config::step::user::data_description::payload%]",
-          "resource": "[%key:component::scrape::config::step::user::data_description::resource%]",
-          "timeout": "[%key:component::scrape::config::step::user::data_description::timeout%]",
-          "verify_ssl": "[%key:component::scrape::config::step::user::data_description::verify_ssl%]"
+          "resource": "[%key:component::scrape::config::step::user::data_description::resource%]"
+        },
+        "sections": {
+          "advanced": {
+            "data": {
+              "encoding": "[%key:component::scrape::config::step::user::sections::advanced::data::encoding%]",
+              "headers": "[%key:component::scrape::config::step::user::sections::advanced::data::headers%]",
+              "timeout": "[%key:component::scrape::config::step::user::sections::advanced::data::timeout%]",
+              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+            },
+            "data_description": {
+              "encoding": "[%key:component::scrape::config::step::user::sections::advanced::data_description::encoding%]",
+              "headers": "[%key:component::scrape::config::step::user::sections::advanced::data_description::headers%]",
+              "timeout": "[%key:component::scrape::config::step::user::sections::advanced::data_description::timeout%]",
+              "verify_ssl": "[%key:component::scrape::config::step::user::sections::advanced::data_description::verify_ssl%]"
+            },
+            "description": "[%key:component::scrape::config::step::user::sections::advanced::description%]",
+            "name": "[%key:component::scrape::config::step::user::sections::advanced::name%]"
+          },
+          "auth": {
+            "data": {
+              "authentication": "[%key:component::scrape::config::step::user::sections::auth::data::authentication%]",
+              "password": "[%key:common::config_flow::data::password%]",
+              "username": "[%key:common::config_flow::data::username%]"
+            },
+            "data_description": {
+              "authentication": "[%key:component::scrape::config::step::user::sections::auth::data_description::authentication%]"
+            },
+            "description": "[%key:component::scrape::config::step::user::sections::auth::description%]",
+            "name": "[%key:component::scrape::config::step::user::sections::auth::name%]"
+          }
         }
       }
     }

tests/components/scrape/conftest.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from collections.abc import Generator
 from typing import Any
 from unittest.mock import AsyncMock, patch
-import uuid
 
 import pytest
 
@@ -26,10 +25,8 @@ from homeassistant.components.scrape.const import (
 from homeassistant.config_entries import SOURCE_USER
 from homeassistant.const import (
     CONF_METHOD,
-    CONF_NAME,
     CONF_RESOURCE,
     CONF_TIMEOUT,
-    CONF_UNIQUE_ID,
     CONF_VERIFY_SSL,
 )
 from homeassistant.core import HomeAssistant
@@ -49,9 +46,9 @@ def mock_setup_entry() -> Generator[AsyncMock]:
         yield mock_setup_entry
 
 
-@pytest.fixture(name="get_config")
-async def get_config_to_integration_load() -> dict[str, Any]:
-    """Return default minimal configuration.
+@pytest.fixture(name="get_resource_config")
+async def get_resource_config_to_integration_load() -> dict[str, Any]:
+    """Return default minimal configuration for resource.
 
     To override the config, tests can be marked with:
     @pytest.mark.parametrize("get_config", [{...}])
@@ -59,20 +56,33 @@ async def get_config_to_integration_load() -> dict[str, Any]:
     return {
         CONF_RESOURCE: "https://www.home-assistant.io",
         CONF_METHOD: DEFAULT_METHOD,
-        CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
-        CONF_TIMEOUT: DEFAULT_TIMEOUT,
-        CONF_ENCODING: DEFAULT_ENCODING,
-        "sensor": [
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            }
-        ],
+        "auth": {},
+        "advanced": {
+            CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
+            CONF_TIMEOUT: DEFAULT_TIMEOUT,
+            CONF_ENCODING: DEFAULT_ENCODING,
+        },
     }
 
 
+@pytest.fixture(name="get_sensor_config")
+async def get_sensor_config_to_integration_load() -> tuple[dict[str, Any], ...]:
+    """Return default minimal configuration for sensor.
+
+    To override the config, tests can be marked with:
+    @pytest.mark.parametrize("get_config", [{...}])
+    """
+    return (
+        {
+            "data": {"advanced": {}, CONF_INDEX: 0, CONF_SELECT: ".current-version h1"},
+            "subentry_id": "01JZN07D8D23994A49YKS649S7",
+            "subentry_type": "entity",
+            "title": "Current version",
+            "unique_id": None,
+        },
+    )
+
+
 @pytest.fixture(name="get_data")
 async def get_data_to_integration_load() -> MockRestData:
     """Return RestData.
@@ -85,14 +95,19 @@ async def get_data_to_integration_load() -> MockRestData:
 
 @pytest.fixture(name="loaded_entry")
 async def load_integration(
-    hass: HomeAssistant, get_config: dict[str, Any], get_data: MockRestData
+    hass: HomeAssistant,
+    get_resource_config: dict[str, Any],
+    get_sensor_config: tuple[dict[str, Any], ...],
+    get_data: MockRestData,
 ) -> MockConfigEntry:
     """Set up the Scrape integration in Home Assistant."""
     config_entry = MockConfigEntry(
         domain=DOMAIN,
         source=SOURCE_USER,
-        options=get_config,
-        entry_id="1",
+        options=get_resource_config,
+        entry_id="01JZN04ZJ9BQXXGXDS05WS7D6P",
+        subentries_data=get_sensor_config,
+        version=2,
     )
 
     config_entry.add_to_hass(hass)
@@ -105,13 +120,3 @@ async def load_integration(
         await hass.async_block_till_done()
 
     return config_entry
-
-
-@pytest.fixture(autouse=True)
-def uuid_fixture() -> str:
-    """Automatically path uuid generator."""
-    with patch(
-        "homeassistant.components.scrape.config_flow.uuid.uuid1",
-        return_value=uuid.UUID("3699ef88-69e6-11ed-a1eb-0242ac120002"),
-    ):
-        yield

tests/components/scrape/snapshots/test_init.ambr

@@ -0,0 +1,151 @@
+# serializer version: 1
+# name: test_migrate_from_version_1_to_2[device_registry]
+  DeviceRegistryEntrySnapshot({
+    'area_id': None,
+    'config_entries': <ANY>,
+    'config_entries_subentries': <ANY>,
+    'configuration_url': None,
+    'connections': set({
+    }),
+    'disabled_by': None,
+    'entry_type': <DeviceEntryType.SERVICE: 'service'>,
+    'hw_version': None,
+    'id': <ANY>,
+    'identifiers': set({
+      tuple(
+        'scrape',
+        '01JZQ1G63X2DX66GZ9ZTFY9PEH',
+      ),
+    }),
+    'labels': set({
+    }),
+    'manufacturer': 'Scrape',
+    'model': None,
+    'model_id': None,
+    'name': 'Current version',
+    'name_by_user': None,
+    'primary_config_entry': <ANY>,
+    'serial_number': None,
+    'sw_version': None,
+    'via_device_id': None,
+  })
+# ---
+# name: test_migrate_from_version_1_to_2[entity_registry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.current_version',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Current version',
+    'platform': 'scrape',
+    'previous_unique_id': 'a0bde946-5c96-11f0-b55f-0242ac110002',
+    'suggested_object_id': 'current_version',
+    'supported_features': 0,
+    'translation_key': None,
+    'unique_id': '01JZQ1G63X2DX66GZ9ZTFY9PEH',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_migrate_from_version_1_to_2[post_migration_config_entry]
+  ConfigEntrySnapshot({
+    'data': dict({
+    }),
+    'disabled_by': None,
+    'discovery_keys': dict({
+    }),
+    'domain': 'scrape',
+    'entry_id': <ANY>,
+    'minor_version': 1,
+    'options': dict({
+      'advanced': dict({
+        'encoding': 'UTF-8',
+        'timeout': 10.0,
+        'verify_ssl': True,
+      }),
+      'auth': dict({
+        'password': 'pass',
+        'username': 'user',
+      }),
+      'method': 'GET',
+      'resource': 'http://www.home-assistant.io',
+    }),
+    'pref_disable_new_entities': False,
+    'pref_disable_polling': False,
+    'source': 'user',
+    'subentries': list([
+      dict({
+        'data': dict({
+          'advanced': dict({
+            'value_template': '{{ value }}',
+          }),
+          'index': 0,
+          'select': '.release-date',
+        }),
+        'subentry_id': '01JZQ1G63X2DX66GZ9ZTFY9PEH',
+        'subentry_type': 'entity',
+        'title': 'Current version',
+        'unique_id': None,
+      }),
+    ]),
+    'title': 'Mock Title',
+    'unique_id': None,
+    'version': 2,
+  })
+# ---
+# name: test_migrate_from_version_1_to_2[pre_migration_config_entry]
+  ConfigEntrySnapshot({
+    'data': dict({
+    }),
+    'disabled_by': None,
+    'discovery_keys': dict({
+    }),
+    'domain': 'scrape',
+    'entry_id': <ANY>,
+    'minor_version': 1,
+    'options': dict({
+      'encoding': 'UTF-8',
+      'method': 'GET',
+      'password': 'pass',
+      'resource': 'http://www.home-assistant.io',
+      'sensor': list([
+        dict({
+          'index': 0,
+          'name': 'Current version',
+          'select': '.release-date',
+          'unique_id': 'a0bde946-5c96-11f0-b55f-0242ac110002',
+          'value_template': '{{ value }}',
+        }),
+      ]),
+      'timeout': 10.0,
+      'username': 'user',
+      'verify_ssl': True,
+    }),
+    'pref_disable_new_entities': False,
+    'pref_disable_polling': False,
+    'source': 'user',
+    'subentries': list([
+    ]),
+    'title': 'Mock Title',
+    'unique_id': None,
+    'version': 1,
+  })
+# ---

tests/components/scrape/test_config_flow.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from unittest.mock import AsyncMock, patch
-import uuid
 
 from homeassistant import config_entries
 from homeassistant.components.rest.data import (  # pylint: disable=hass-component-root-import
@@ -14,25 +13,21 @@ from homeassistant.components.rest.schema import (  # pylint: disable=hass-compo
 )
 from homeassistant.components.scrape import DOMAIN
 from homeassistant.components.scrape.const import (
+    CONF_ADVANCED,
+    CONF_AUTH,
     CONF_ENCODING,
     CONF_INDEX,
     CONF_SELECT,
     DEFAULT_ENCODING,
     DEFAULT_VERIFY_SSL,
 )
-from homeassistant.components.sensor import CONF_STATE_CLASS
 from homeassistant.const import (
-    CONF_DEVICE_CLASS,
     CONF_METHOD,
-    CONF_NAME,
     CONF_PASSWORD,
     CONF_PAYLOAD,
     CONF_RESOURCE,
     CONF_TIMEOUT,
-    CONF_UNIQUE_ID,
-    CONF_UNIT_OF_MEASUREMENT,
     CONF_USERNAME,
-    CONF_VALUE_TEMPLATE,
     CONF_VERIFY_SSL,
 )
 from homeassistant.core import HomeAssistant
@@ -44,7 +39,7 @@ from . import MockRestData
 from tests.common import MockConfigEntry
 
 
-async def test_form(
+async def test_entry_and_subentry(
     hass: HomeAssistant, get_data: MockRestData, mock_setup_entry: AsyncMock
 ) -> None:
     """Test we get the form."""
@@ -59,47 +54,55 @@ async def test_form(
         "homeassistant.components.rest.RestData",
         return_value=get_data,
     ) as mock_data:
-        result2 = await hass.config_entries.flow.async_configure(
+        result = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             {
                 CONF_RESOURCE: "https://www.home-assistant.io",
                 CONF_METHOD: "GET",
-                CONF_VERIFY_SSL: True,
-                CONF_TIMEOUT: 10.0,
+                CONF_AUTH: {},
+                CONF_ADVANCED: {
+                    CONF_VERIFY_SSL: True,
+                    CONF_TIMEOUT: 10.0,
+                },
             },
         )
-        await hass.async_block_till_done()
-        result3 = await hass.config_entries.flow.async_configure(
-            result2["flow_id"],
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0.0,
-            },
-        )
-        await hass.async_block_till_done()
 
-    assert result3["type"] is FlowResultType.CREATE_ENTRY
-    assert result3["version"] == 1
-    assert result3["options"] == {
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["version"] == 2
+    assert result["options"] == {
         CONF_RESOURCE: "https://www.home-assistant.io",
         CONF_METHOD: "GET",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10.0,
-        CONF_ENCODING: "UTF-8",
-        "sensor": [
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0.0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            }
-        ],
+        CONF_AUTH: {},
+        CONF_ADVANCED: {
+            CONF_VERIFY_SSL: True,
+            CONF_TIMEOUT: 10.0,
+            CONF_ENCODING: "UTF-8",
+        },
     }
 
     assert len(mock_data.mock_calls) == 1
     assert len(mock_setup_entry.mock_calls) == 1
 
+    entry_id = result["result"].entry_id
+
+    result = await hass.config_entries.subentries.async_init(
+        (entry_id, "entity"), context={"source": config_entries.SOURCE_USER}
+    )
+    assert result["step_id"] == "user"
+    assert result["type"] is FlowResultType.FORM
+
+    result = await hass.config_entries.subentries.async_configure(
+        result["flow_id"],
+        {CONF_INDEX: 0, CONF_SELECT: ".current-version h1", CONF_ADVANCED: {}},
+    )
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["data"] == {
+        CONF_INDEX: 0,
+        CONF_SELECT: ".current-version h1",
+        CONF_ADVANCED: {},
+    }
+
 
 async def test_form_with_post(
     hass: HomeAssistant, get_data: MockRestData, mock_setup_entry: AsyncMock
@@ -116,44 +119,32 @@ async def test_form_with_post(
         "homeassistant.components.rest.RestData",
         return_value=get_data,
     ) as mock_data:
-        result2 = await hass.config_entries.flow.async_configure(
+        result = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             {
                 CONF_RESOURCE: "https://www.home-assistant.io",
                 CONF_METHOD: "GET",
                 CONF_PAYLOAD: "POST",
-                CONF_VERIFY_SSL: True,
-                CONF_TIMEOUT: 10.0,
+                CONF_AUTH: {},
+                CONF_ADVANCED: {
+                    CONF_VERIFY_SSL: True,
+                    CONF_TIMEOUT: 10.0,
+                },
             },
         )
-        await hass.async_block_till_done()
-        result3 = await hass.config_entries.flow.async_configure(
-            result2["flow_id"],
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0.0,
-            },
-        )
-        await hass.async_block_till_done()
 
-    assert result3["type"] is FlowResultType.CREATE_ENTRY
-    assert result3["version"] == 1
-    assert result3["options"] == {
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["version"] == 2
+    assert result["options"] == {
         CONF_RESOURCE: "https://www.home-assistant.io",
         CONF_METHOD: "GET",
         CONF_PAYLOAD: "POST",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10.0,
-        CONF_ENCODING: "UTF-8",
-        "sensor": [
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0.0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            }
-        ],
+        CONF_AUTH: {},
+        CONF_ADVANCED: {
+            CONF_VERIFY_SSL: True,
+            CONF_TIMEOUT: 10.0,
+            CONF_ENCODING: "UTF-8",
+        },
     }
 
     assert len(mock_data.mock_calls) == 1
@@ -176,74 +167,68 @@ async def test_flow_fails(
         "homeassistant.components.rest.RestData",
         side_effect=HomeAssistantError,
     ):
-        result2 = await hass.config_entries.flow.async_configure(
+        result = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input={
                 CONF_RESOURCE: "https://www.home-assistant.io",
                 CONF_METHOD: "GET",
-                CONF_VERIFY_SSL: True,
-                CONF_TIMEOUT: 10.0,
+                CONF_AUTH: {},
+                CONF_ADVANCED: {
+                    CONF_VERIFY_SSL: True,
+                    CONF_TIMEOUT: 10.0,
+                },
             },
         )
 
-    assert result2["errors"] == {"base": "resource_error"}
+    assert result["errors"] == {"base": "resource_error"}
 
     with patch(
         "homeassistant.components.rest.RestData",
         return_value=MockRestData("test_scrape_sensor_no_data"),
     ):
-        result2 = await hass.config_entries.flow.async_configure(
+        result = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input={
                 CONF_RESOURCE: "https://www.home-assistant.io",
                 CONF_METHOD: "GET",
-                CONF_VERIFY_SSL: True,
-                CONF_TIMEOUT: 10.0,
+                CONF_AUTH: {},
+                CONF_ADVANCED: {
+                    CONF_VERIFY_SSL: True,
+                    CONF_TIMEOUT: 10.0,
+                },
             },
         )
 
-    assert result2["errors"] == {"base": "resource_error"}
+    assert result["errors"] == {"base": "no_data"}
 
     with patch(
         "homeassistant.components.rest.RestData",
         return_value=get_data,
     ):
-        result3 = await hass.config_entries.flow.async_configure(
+        result = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             {
                 CONF_RESOURCE: "https://www.home-assistant.io",
                 CONF_METHOD: "GET",
-                CONF_VERIFY_SSL: True,
-                CONF_TIMEOUT: 10.0,
+                CONF_AUTH: {},
+                CONF_ADVANCED: {
+                    CONF_VERIFY_SSL: True,
+                    CONF_TIMEOUT: 10.0,
+                },
             },
         )
-        await hass.async_block_till_done()
-        result4 = await hass.config_entries.flow.async_configure(
-            result3["flow_id"],
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0.0,
-            },
-        )
-        await hass.async_block_till_done()
 
-    assert result4["type"] is FlowResultType.CREATE_ENTRY
-    assert result4["title"] == "https://www.home-assistant.io"
-    assert result4["options"] == {
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "https://www.home-assistant.io"
+    assert result["options"] == {
         CONF_RESOURCE: "https://www.home-assistant.io",
         CONF_METHOD: "GET",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10.0,
-        CONF_ENCODING: "UTF-8",
-        "sensor": [
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0.0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            }
-        ],
+        CONF_AUTH: {},
+        CONF_ADVANCED: {
+            CONF_VERIFY_SSL: True,
+            CONF_TIMEOUT: 10.0,
+            CONF_ENCODING: "UTF-8",
+        },
     }
 
 
@@ -257,16 +242,8 @@ async def test_options_resource_flow(
 
     result = await hass.config_entries.options.async_init(loaded_entry.entry_id)
 
-    assert result["type"] is FlowResultType.MENU
-    assert result["step_id"] == "init"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"next_step_id": "resource"},
-    )
-
     assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "resource"
+    assert result["step_id"] == "init"
 
     mocker = MockRestData("test_scrape_sensor2")
     with patch("homeassistant.components.rest.RestData", return_value=mocker):
@@ -275,11 +252,15 @@ async def test_options_resource_flow(
             user_input={
                 CONF_RESOURCE: "https://www.home-assistant.io",
                 CONF_METHOD: DEFAULT_METHOD,
-                CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
-                CONF_TIMEOUT: DEFAULT_TIMEOUT,
-                CONF_ENCODING: DEFAULT_ENCODING,
-                CONF_USERNAME: "secret_username",
-                CONF_PASSWORD: "secret_password",
+                CONF_AUTH: {
+                    CONF_USERNAME: "secret_username",
+                    CONF_PASSWORD: "secret_password",
+                },
+                CONF_ADVANCED: {
+                    CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
+                    CONF_TIMEOUT: DEFAULT_TIMEOUT,
+                    CONF_ENCODING: DEFAULT_ENCODING,
+                },
             },
         )
         await hass.async_block_till_done()
@@ -288,19 +269,15 @@ async def test_options_resource_flow(
     assert result["data"] == {
         CONF_RESOURCE: "https://www.home-assistant.io",
         CONF_METHOD: "GET",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10.0,
-        CONF_ENCODING: "UTF-8",
-        CONF_USERNAME: "secret_username",
-        CONF_PASSWORD: "secret_password",
-        "sensor": [
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0.0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            }
-        ],
+        CONF_AUTH: {
+            CONF_USERNAME: "secret_username",
+            CONF_PASSWORD: "secret_password",
+        },
+        CONF_ADVANCED: {
+            CONF_VERIFY_SSL: True,
+            CONF_TIMEOUT: 10.0,
+            CONF_ENCODING: "UTF-8",
+        },
     }
 
     await hass.async_block_till_done()
@@ -311,351 +288,3 @@ async def test_options_resource_flow(
     # Check the state of the entity has changed as expected
     state = hass.states.get("sensor.current_version")
     assert state.state == "Hidden Version: 2021.12.10"
-
-
-async def test_options_add_remove_sensor_flow(
-    hass: HomeAssistant, loaded_entry: MockConfigEntry
-) -> None:
-    """Test options flow to add and remove a sensor."""
-
-    state = hass.states.get("sensor.current_version")
-    assert state.state == "Current Version: 2021.12.10"
-
-    result = await hass.config_entries.options.async_init(loaded_entry.entry_id)
-
-    assert result["type"] is FlowResultType.MENU
-    assert result["step_id"] == "init"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"next_step_id": "add_sensor"},
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "add_sensor"
-
-    mocker = MockRestData("test_scrape_sensor2")
-    with (
-        patch("homeassistant.components.rest.RestData", return_value=mocker),
-        patch(
-            "homeassistant.components.scrape.config_flow.uuid.uuid1",
-            return_value=uuid.UUID("3699ef88-69e6-11ed-a1eb-0242ac120003"),
-        ),
-    ):
-        result = await hass.config_entries.options.async_configure(
-            result["flow_id"],
-            user_input={
-                CONF_NAME: "Template",
-                CONF_SELECT: "template",
-                CONF_INDEX: 0.0,
-            },
-        )
-        await hass.async_block_till_done()
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["data"] == {
-        CONF_RESOURCE: "https://www.home-assistant.io",
-        CONF_METHOD: "GET",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10,
-        CONF_ENCODING: "UTF-8",
-        "sensor": [
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: ".current-version h1",
-                CONF_INDEX: 0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            },
-            {
-                CONF_NAME: "Template",
-                CONF_SELECT: "template",
-                CONF_INDEX: 0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120003",
-            },
-        ],
-    }
-
-    await hass.async_block_till_done()
-
-    # Check the entity was updated, with the new entity
-    assert len(hass.states.async_all()) == 2
-
-    # Check the state of the entity has changed as expected
-    state = hass.states.get("sensor.current_version")
-    assert state.state == "Hidden Version: 2021.12.10"
-
-    state = hass.states.get("sensor.template")
-    assert state.state == "Trying to get"
-
-    # Now remove the original sensor
-
-    result = await hass.config_entries.options.async_init(loaded_entry.entry_id)
-
-    assert result["type"] is FlowResultType.MENU
-    assert result["step_id"] == "init"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"next_step_id": "remove_sensor"},
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "remove_sensor"
-
-    mocker = MockRestData("test_scrape_sensor2")
-    with patch("homeassistant.components.rest.RestData", return_value=mocker):
-        result = await hass.config_entries.options.async_configure(
-            result["flow_id"],
-            user_input={
-                CONF_INDEX: ["0"],
-            },
-        )
-        await hass.async_block_till_done()
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["data"] == {
-        CONF_RESOURCE: "https://www.home-assistant.io",
-        CONF_METHOD: "GET",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10,
-        CONF_ENCODING: "UTF-8",
-        "sensor": [
-            {
-                CONF_NAME: "Template",
-                CONF_SELECT: "template",
-                CONF_INDEX: 0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120003",
-            },
-        ],
-    }
-
-    await hass.async_block_till_done()
-
-    # Check the original entity was removed, with only the new entity left
-    assert len(hass.states.async_all()) == 1
-
-    # Check the state of the new entity
-    state = hass.states.get("sensor.template")
-    assert state.state == "Trying to get"
-
-
-async def test_options_edit_sensor_flow(
-    hass: HomeAssistant, loaded_entry: MockConfigEntry
-) -> None:
-    """Test options flow to edit a sensor."""
-
-    state = hass.states.get("sensor.current_version")
-    assert state.state == "Current Version: 2021.12.10"
-
-    result = await hass.config_entries.options.async_init(loaded_entry.entry_id)
-
-    assert result["type"] is FlowResultType.MENU
-    assert result["step_id"] == "init"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"next_step_id": "select_edit_sensor"},
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "select_edit_sensor"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"index": "0"},
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "edit_sensor"
-
-    mocker = MockRestData("test_scrape_sensor2")
-    with patch("homeassistant.components.rest.RestData", return_value=mocker):
-        result = await hass.config_entries.options.async_configure(
-            result["flow_id"],
-            user_input={
-                CONF_SELECT: "template",
-                CONF_INDEX: 0.0,
-            },
-        )
-        await hass.async_block_till_done()
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["data"] == {
-        CONF_RESOURCE: "https://www.home-assistant.io",
-        CONF_METHOD: "GET",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10,
-        CONF_ENCODING: "UTF-8",
-        "sensor": [
-            {
-                CONF_NAME: "Current version",
-                CONF_SELECT: "template",
-                CONF_INDEX: 0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            },
-        ],
-    }
-
-    await hass.async_block_till_done()
-
-    # Check the entity was updated
-    assert len(hass.states.async_all()) == 1
-
-    # Check the state of the entity has changed as expected
-    state = hass.states.get("sensor.current_version")
-    assert state.state == "Trying to get"
-
-
-async def test_sensor_options_add_device_class(
-    hass: HomeAssistant, mock_setup_entry: AsyncMock
-) -> None:
-    """Test options flow to edit a sensor."""
-    entry = MockConfigEntry(
-        domain=DOMAIN,
-        options={
-            CONF_RESOURCE: "https://www.home-assistant.io",
-            CONF_METHOD: DEFAULT_METHOD,
-            CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
-            CONF_TIMEOUT: DEFAULT_TIMEOUT,
-            CONF_ENCODING: DEFAULT_ENCODING,
-            "sensor": [
-                {
-                    CONF_NAME: "Current Temp",
-                    CONF_SELECT: ".current-temp h3",
-                    CONF_INDEX: 0,
-                    CONF_VALUE_TEMPLATE: "{{ value.split(':')[1] }}",
-                    CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-                }
-            ],
-        },
-        entry_id="1",
-    )
-    entry.add_to_hass(hass)
-
-    result = await hass.config_entries.options.async_init(entry.entry_id)
-    assert result["type"] is FlowResultType.MENU
-    assert result["step_id"] == "init"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"next_step_id": "select_edit_sensor"},
-    )
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "select_edit_sensor"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"index": "0"},
-    )
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "edit_sensor"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        user_input={
-            CONF_SELECT: ".current-temp h3",
-            CONF_INDEX: 0.0,
-            CONF_VALUE_TEMPLATE: "{{ value.split(':')[1] }}",
-            CONF_DEVICE_CLASS: "temperature",
-            CONF_STATE_CLASS: "measurement",
-            CONF_UNIT_OF_MEASUREMENT: "°C",
-        },
-    )
-    await hass.async_block_till_done()
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["data"] == {
-        CONF_RESOURCE: "https://www.home-assistant.io",
-        CONF_METHOD: "GET",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10,
-        CONF_ENCODING: "UTF-8",
-        "sensor": [
-            {
-                CONF_NAME: "Current Temp",
-                CONF_SELECT: ".current-temp h3",
-                CONF_VALUE_TEMPLATE: "{{ value.split(':')[1] }}",
-                CONF_INDEX: 0,
-                CONF_DEVICE_CLASS: "temperature",
-                CONF_STATE_CLASS: "measurement",
-                CONF_UNIT_OF_MEASUREMENT: "°C",
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            },
-        ],
-    }
-
-
-async def test_sensor_options_remove_device_class(
-    hass: HomeAssistant, mock_setup_entry: AsyncMock
-) -> None:
-    """Test options flow to edit a sensor."""
-    entry = MockConfigEntry(
-        domain=DOMAIN,
-        options={
-            CONF_RESOURCE: "https://www.home-assistant.io",
-            CONF_METHOD: DEFAULT_METHOD,
-            CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
-            CONF_TIMEOUT: DEFAULT_TIMEOUT,
-            CONF_ENCODING: DEFAULT_ENCODING,
-            "sensor": [
-                {
-                    CONF_NAME: "Current Temp",
-                    CONF_SELECT: ".current-temp h3",
-                    CONF_INDEX: 0,
-                    CONF_VALUE_TEMPLATE: "{{ value.split(':')[1] }}",
-                    CONF_DEVICE_CLASS: "temperature",
-                    CONF_STATE_CLASS: "measurement",
-                    CONF_UNIT_OF_MEASUREMENT: "°C",
-                    CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-                }
-            ],
-        },
-        entry_id="1",
-    )
-    entry.add_to_hass(hass)
-
-    result = await hass.config_entries.options.async_init(entry.entry_id)
-    assert result["type"] is FlowResultType.MENU
-    assert result["step_id"] == "init"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"next_step_id": "select_edit_sensor"},
-    )
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "select_edit_sensor"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        {"index": "0"},
-    )
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "edit_sensor"
-
-    result = await hass.config_entries.options.async_configure(
-        result["flow_id"],
-        user_input={
-            CONF_SELECT: ".current-temp h3",
-            CONF_INDEX: 0.0,
-            CONF_VALUE_TEMPLATE: "{{ value.split(':')[1] }}",
-        },
-    )
-    await hass.async_block_till_done()
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["data"] == {
-        CONF_RESOURCE: "https://www.home-assistant.io",
-        CONF_METHOD: "GET",
-        CONF_VERIFY_SSL: True,
-        CONF_TIMEOUT: 10,
-        CONF_ENCODING: "UTF-8",
-        "sensor": [
-            {
-                CONF_NAME: "Current Temp",
-                CONF_SELECT: ".current-temp h3",
-                CONF_VALUE_TEMPLATE: "{{ value.split(':')[1] }}",
-                CONF_INDEX: 0,
-                CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-            },
-        ],
-    }

tests/components/scrape/test_init.py

@@ -2,14 +2,18 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from http import HTTPStatus
+from typing import Any
 from unittest.mock import patch
 
 from freezegun.api import FrozenDateTimeFactory
 import pytest
+from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.scrape.const import DEFAULT_SCAN_INTERVAL, DOMAIN
-from homeassistant.config_entries import ConfigEntryState
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
+from homeassistant.config_entries import SOURCE_USER, ConfigEntryState, ConfigSubentry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.setup import async_setup_component
@@ -193,3 +197,137 @@ async def test_resource_template(
     await hass.async_block_till_done(wait_background_tasks=True)
     state = hass.states.get("sensor.template_sensor")
     assert state.state == "Second"
+
+
+async def test_migrate_from_future(
+    hass: HomeAssistant,
+    get_resource_config: dict[str, Any],
+    get_sensor_config: tuple[dict[str, Any], ...],
+    get_data: MockRestData,
+) -> None:
+    """Test migration from future version fails."""
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        source=SOURCE_USER,
+        options=get_resource_config,
+        entry_id="01JZN04ZJ9BQXXGXDS05WS7D6P",
+        subentries_data=get_sensor_config,
+        version=3,
+    )
+
+    config_entry.add_to_hass(hass)
+
+    with patch(
+        "homeassistant.components.rest.RestData",
+        return_value=get_data,
+    ):
+        await hass.config_entries.async_setup(config_entry.entry_id)
+        await hass.async_block_till_done()
+
+    assert config_entry.state is ConfigEntryState.MIGRATION_ERROR
+
+
+async def test_migrate_from_version_1_to_2(
+    hass: HomeAssistant,
+    get_data: MockRestData,
+    device_registry: dr.DeviceRegistry,
+    entity_registry: er.EntityRegistry,
+    snapshot: SnapshotAssertion,
+) -> None:
+    """Test migration from version 1.1 to 2.1 with config subentries."""
+
+    @dataclass(frozen=True, kw_only=True)
+    class MockConfigSubentry(ConfigSubentry):
+        """Container for a configuration subentry."""
+
+        subentry_id: str = "01JZQ1G63X2DX66GZ9ZTFY9PEH"
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        source=SOURCE_USER,
+        options={
+            "encoding": "UTF-8",
+            "method": "GET",
+            "resource": "http://www.home-assistant.io",
+            "username": "user",
+            "password": "pass",
+            "sensor": [
+                {
+                    "index": 0,
+                    "name": "Current version",
+                    "select": ".release-date",
+                    "unique_id": "a0bde946-5c96-11f0-b55f-0242ac110002",
+                    "value_template": "{{ value }}",
+                }
+            ],
+            "timeout": 10.0,
+            "verify_ssl": True,
+        },
+        entry_id="01JZN04ZJ9BQXXGXDS05WS7D6P",
+        version=1,
+    )
+    config_entry.add_to_hass(hass)
+    device = device_registry.async_get_or_create(
+        config_entry_id=config_entry.entry_id,
+        entry_type=dr.DeviceEntryType.SERVICE,
+        identifiers={(DOMAIN, "a0bde946-5c96-11f0-b55f-0242ac110002")},
+        manufacturer="Scrape",
+        name="Current version",
+    )
+    entity_registry.async_get_or_create(
+        SENSOR_DOMAIN,
+        DOMAIN,
+        "a0bde946-5c96-11f0-b55f-0242ac110002",
+        config_entry=config_entry,
+        device_id=device.id,
+        original_name="Current version",
+        has_entity_name=True,
+        suggested_object_id="current_version",
+    )
+    assert hass.config_entries.async_get_entry(config_entry.entry_id) == snapshot(
+        name="pre_migration_config_entry"
+    )
+    with (
+        patch(
+            "homeassistant.components.rest.RestData",
+            return_value=get_data,
+        ),
+        patch("homeassistant.components.scrape.ConfigSubentry", MockConfigSubentry),
+    ):
+        await hass.config_entries.async_setup(config_entry.entry_id)
+        await hass.async_block_till_done(wait_background_tasks=True)
+
+    assert config_entry.state is ConfigEntryState.LOADED
+
+    assert hass.config_entries.async_get_entry(config_entry.entry_id) == snapshot(
+        name="post_migration_config_entry"
+    )
+    device = device_registry.async_get(device.id)
+    assert device == snapshot(name="device_registry")
+    entity = entity_registry.async_get("sensor.current_version")
+    assert entity == snapshot(name="entity_registry")
+
+    assert config_entry.subentries == {
+        "01JZQ1G63X2DX66GZ9ZTFY9PEH": MockConfigSubentry(
+            data={
+                "advanced": {"value_template": "{{ value }}"},
+                "index": 0,
+                "select": ".release-date",
+            },
+            subentry_id="01JZQ1G63X2DX66GZ9ZTFY9PEH",
+            subentry_type="entity",
+            title="Current version",
+            unique_id=None,
+        ),
+    }
+    assert device.config_entries == {"01JZN04ZJ9BQXXGXDS05WS7D6P"}
+    assert device.config_entries_subentries == {
+        "01JZN04ZJ9BQXXGXDS05WS7D6P": {
+            "01JZQ1G63X2DX66GZ9ZTFY9PEH",
+        },
+    }
+    assert entity.config_entry_id == config_entry.entry_id
+    assert entity.config_subentry_id == "01JZQ1G63X2DX66GZ9ZTFY9PEH"
+
+    state = hass.states.get("sensor.current_version")
+    assert state.state == "January 17, 2022"

tests/components/scrape/test_sensor.py

@@ -18,7 +18,6 @@ from homeassistant.components.scrape.const import (
 )
 from homeassistant.components.sensor import (
     CONF_STATE_CLASS,
-    DOMAIN as SENSOR_DOMAIN,
     SensorDeviceClass,
     SensorStateClass,
 )
@@ -494,7 +493,7 @@ async def test_setup_config_entry(
 
     entity = entity_registry.async_get("sensor.current_version")
 
-    assert entity.unique_id == "3699ef88-69e6-11ed-a1eb-0242ac120002"
+    assert entity.unique_id == "01JZN07D8D23994A49YKS649S7"
 
 
 async def test_templates_with_yaml(hass: HomeAssistant) -> None:
@@ -578,27 +577,38 @@ async def test_templates_with_yaml(hass: HomeAssistant) -> None:
 
 
 @pytest.mark.parametrize(
-    "get_config",
+    ("get_resource_config", "get_sensor_config"),
     [
-        {
-            CONF_RESOURCE: "https://www.home-assistant.io",
-            CONF_METHOD: "GET",
-            CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
-            CONF_TIMEOUT: 10,
-            CONF_ENCODING: DEFAULT_ENCODING,
-            SENSOR_DOMAIN: [
+        (
+            {
+                CONF_RESOURCE: "https://www.home-assistant.io",
+                CONF_METHOD: "GET",
+                "auth": {},
+                "advanced": {
+                    CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL,
+                    CONF_TIMEOUT: 10,
+                    CONF_ENCODING: DEFAULT_ENCODING,
+                },
+            },
+            (
                 {
-                    CONF_SELECT: ".current-version h1",
-                    CONF_NAME: "Current version",
-                    CONF_VALUE_TEMPLATE: "{{ value.split(':')[1] }}",
-                    CONF_INDEX: 0,
-                    CONF_UNIQUE_ID: "3699ef88-69e6-11ed-a1eb-0242ac120002",
-                    CONF_AVAILABILITY: '{{ states("sensor.input1")=="on" }}',
-                    CONF_ICON: 'mdi:o{{ "n" if states("sensor.input1")=="on" else "ff" }}',
-                    CONF_PICTURE: 'o{{ "n" if states("sensor.input1")=="on" else "ff" }}.jpg',
-                }
-            ],
-        }
+                    "data": {
+                        CONF_SELECT: ".current-version h1",
+                        CONF_INDEX: 0,
+                        "advanced": {
+                            CONF_VALUE_TEMPLATE: "{{ value.split(':')[1] }}",
+                            CONF_AVAILABILITY: '{{ states("sensor.input1")=="on" }}',
+                            CONF_ICON: 'mdi:o{{ "n" if states("sensor.input1")=="on" else "ff" }}',
+                            CONF_PICTURE: 'o{{ "n" if states("sensor.input1")=="on" else "ff" }}.jpg',
+                        },
+                    },
+                    # "subentry_id": "01JZN07D8D23994A49YKS649S7",
+                    "subentry_type": "entity",
+                    "title": "Current version",
+                    "unique_id": None,
+                },
+            ),
+        )
     ],
 )
 async def test_availability(