Add two-step options flow for experimental features

When experimental features is enabled, the flow now proceeds to a
second step showing the entity selector for external temperature
sensor. This provides a better UX than requiring users to save and
re-open the config to see the entity selector.

Author: ashleigh-hopkins

custom_components/mitsubishi/config_flow.py

@@ -134,50 +134,38 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
     def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
         """Initialize options flow."""
         self._config_entry = config_entry
+        self._connection_data: dict[str, Any] = {}
+        self._experimental_features: bool = False
 
     @property
     def config_entry(self) -> config_entries.ConfigEntry:
         """Return the config entry."""
         return self._config_entry
 
     async def async_step_init(self, user_input: dict[str, Any] | None = None) -> Any:
-        """Manage the options."""
+        """Step 1: Connection settings and experimental features toggle."""
         errors: dict[str, str] = {}
 
         if user_input is not None:
-            _LOGGER.debug("Processing options user input: %s", user_input)
+            _LOGGER.debug("Processing options step init: %s", user_input)
             try:
-                # Separate options from connection data
-                experimental_features = user_input.pop(CONF_EXPERIMENTAL_FEATURES, False)
-                external_temp_entity = user_input.pop(CONF_EXTERNAL_TEMP_ENTITY, None)
+                # Extract experimental features flag
+                self._experimental_features = user_input.pop(CONF_EXPERIMENTAL_FEATURES, False)
 
                 # Validate the connection configuration
                 _LOGGER.debug("Validating new configuration")
                 await validate_input(self.hass, user_input)
                 _LOGGER.debug("Validation successful for options")
 
-                # Update the config entry data (connection settings)
-                self.hass.config_entries.async_update_entry(
-                    self.config_entry,
-                    data=user_input,
-                )
-
-                # Trigger reload of the integration to apply changes
-                await self.hass.config_entries.async_reload(self.config_entry.entry_id)
-
-                # Build new options, preserving remote_temp_mode if it exists
-                new_options = {
-                    CONF_EXPERIMENTAL_FEATURES: experimental_features,
-                }
-                if experimental_features and external_temp_entity:
-                    new_options[CONF_EXTERNAL_TEMP_ENTITY] = external_temp_entity
-                # Preserve remote_temp_mode from existing options
-                if CONF_REMOTE_TEMP_MODE in self.config_entry.options:
-                    new_options[CONF_REMOTE_TEMP_MODE] = self.config_entry.options[
-                        CONF_REMOTE_TEMP_MODE
-                    ]
-
-                return self.async_create_entry(title="", data=new_options)
+                # Store connection data for later
+                self._connection_data = user_input
+
+                # If experimental features enabled, go to step 2 for entity selection
+                if self._experimental_features:
+                    return await self.async_step_experimental()
+
+                # Otherwise, save and finish
+                return await self._async_save_options(external_temp_entity=None)
 
             except CannotConnect:
                 _LOGGER.error("Cannot connect to device with new settings")
@@ -201,36 +189,67 @@ async def async_step_init(self, user_input: dict[str, Any] | None = None) -> Any
             CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
         )
         current_experimental = self.config_entry.options.get(CONF_EXPERIMENTAL_FEATURES, False)
-        current_external_temp_entity = self.config_entry.options.get(CONF_EXTERNAL_TEMP_ENTITY, "")
 
-        # Base schema with connection settings
-        schema_dict = {
-            vol.Required(CONF_HOST, default=current_host): str,
-            vol.Optional(CONF_ENCRYPTION_KEY, default=current_encryption_key): str,
-            vol.Optional(CONF_ADMIN_USERNAME, default=current_admin_username): str,
-            vol.Optional(CONF_ADMIN_PASSWORD, default=current_admin_password): str,
-            vol.Optional(CONF_SCAN_INTERVAL, default=current_scan_interval): vol.All(
-                vol.Coerce(int), vol.Range(min=10, max=300)
-            ),
-            vol.Optional(CONF_EXPERIMENTAL_FEATURES, default=current_experimental): bool,
-        }
+        options_schema = vol.Schema(
+            {
+                vol.Required(CONF_HOST, default=current_host): str,
+                vol.Optional(CONF_ENCRYPTION_KEY, default=current_encryption_key): str,
+                vol.Optional(CONF_ADMIN_USERNAME, default=current_admin_username): str,
+                vol.Optional(CONF_ADMIN_PASSWORD, default=current_admin_password): str,
+                vol.Optional(CONF_SCAN_INTERVAL, default=current_scan_interval): vol.All(
+                    vol.Coerce(int), vol.Range(min=10, max=300)
+                ),
+                vol.Optional(CONF_EXPERIMENTAL_FEATURES, default=current_experimental): bool,
+            }
+        )
+
+        return self.async_show_form(step_id="init", data_schema=options_schema, errors=errors)
+
+    async def async_step_experimental(self, user_input: dict[str, Any] | None = None) -> Any:
+        """Step 2: Configure experimental features (external temperature sensor)."""
+        if user_input is not None:
+            external_temp_entity = user_input.get(CONF_EXTERNAL_TEMP_ENTITY)
+            return await self._async_save_options(external_temp_entity=external_temp_entity)
 
-        # Only show external temp entity selector if experimental features are enabled
-        if current_experimental:
-            schema_dict[
+        current_external_temp_entity = self.config_entry.options.get(CONF_EXTERNAL_TEMP_ENTITY, "")
+
+        experimental_schema = vol.Schema(
+            {
                 vol.Optional(
                     CONF_EXTERNAL_TEMP_ENTITY,
                     description={"suggested_value": current_external_temp_entity},
-                )
-            ] = selector.EntitySelector(
-                selector.EntitySelectorConfig(
-                    domain=["sensor", "input_number", "number"],
-                )
-            )
+                ): selector.EntitySelector(
+                    selector.EntitySelectorConfig(
+                        domain=["sensor", "input_number", "number"],
+                    )
+                ),
+            }
+        )
 
-        options_schema = vol.Schema(schema_dict)
+        return self.async_show_form(step_id="experimental", data_schema=experimental_schema)
 
-        return self.async_show_form(step_id="init", data_schema=options_schema, errors=errors)
+    async def _async_save_options(self, external_temp_entity: str | None) -> Any:
+        """Save connection data and options."""
+        # Update the config entry data (connection settings)
+        self.hass.config_entries.async_update_entry(
+            self.config_entry,
+            data=self._connection_data,
+        )
+
+        # Trigger reload of the integration to apply changes
+        await self.hass.config_entries.async_reload(self.config_entry.entry_id)
+
+        # Build new options
+        new_options: dict[str, Any] = {
+            CONF_EXPERIMENTAL_FEATURES: self._experimental_features,
+        }
+        if self._experimental_features and external_temp_entity:
+            new_options[CONF_EXTERNAL_TEMP_ENTITY] = external_temp_entity
+        # Preserve remote_temp_mode from existing options
+        if CONF_REMOTE_TEMP_MODE in self.config_entry.options:
+            new_options[CONF_REMOTE_TEMP_MODE] = self.config_entry.options[CONF_REMOTE_TEMP_MODE]
+
+        return self.async_create_entry(title="", data=new_options)
 
 
 class CannotConnect(HomeAssistantError):

custom_components/mitsubishi/strings.json

@@ -34,11 +34,19 @@
           "admin_password": "Admin Password (default: me1debug@0567)",
           "scan_interval": "Update Interval (seconds, 10-300)",
           "enable_capability_detection": "Enable capability detection",
-          "experimental_features": "Enable experimental features",
+          "experimental_features": "Enable experimental features"
+        },
+        "data_description": {
+          "experimental_features": "Enable experimental features like remote temperature sensor support. These features may change or be removed in future versions."
+        }
+      },
+      "experimental": {
+        "title": "Experimental Features Configuration",
+        "description": "⚠️ WARNING: The remote temperature feature should NOT be used for critical heating/cooling needs. If your Home Assistant server goes offline, your external sensor becomes unavailable, or provides invalid readings, the AC will NOT automatically revert to its internal sensor. You must manually switch back to Internal mode.",
+        "data": {
           "external_temperature_entity": "External Temperature Sensor"
         },
         "data_description": {
-          "experimental_features": "Enable experimental features like remote temperature sensor support. These features may change or be removed in future versions. WARNING: The remote temperature feature should NOT be used for critical heating/cooling needs. If your Home Assistant server goes offline, your external sensor becomes unavailable, or provides invalid readings, the AC will NOT automatically revert to its internal sensor. You must manually switch back to Internal mode.",
           "external_temperature_entity": "Select a temperature sensor to use as the room temperature when Remote mode is selected. Leave empty to only use the internal sensor. The AC must receive regular temperature updates - if updates stop, the AC continues using the last received value indefinitely."
         }
       }

tests/test_config_flow.py

@@ -18,6 +18,8 @@
     CONF_ADMIN_PASSWORD,
     CONF_ADMIN_USERNAME,
     CONF_ENCRYPTION_KEY,
+    CONF_EXPERIMENTAL_FEATURES,
+    CONF_EXTERNAL_TEMP_ENTITY,
     CONF_SCAN_INTERVAL,
     DOMAIN,
 )
@@ -346,7 +348,7 @@ async def test_options_flow_init(self, hass: HomeAssistant, mock_config_entry):
         assert CONF_SCAN_INTERVAL in schema_keys
 
     async def test_options_flow_successful_update(self, hass: HomeAssistant, mock_config_entry):
-        """Test successful options flow update."""
+        """Test successful options flow update without experimental features."""
         # Mock the config entries registry methods
         hass.config_entries.async_update_entry = MagicMock()
         hass.config_entries.async_reload = AsyncMock()
@@ -361,6 +363,7 @@ async def test_options_flow_successful_update(self, hass: HomeAssistant, mock_co
             CONF_SCAN_INTERVAL: 60,
             CONF_ADMIN_USERNAME: "admin",
             CONF_ADMIN_PASSWORD: "password",
+            CONF_EXPERIMENTAL_FEATURES: False,
         }
 
         with patch(
@@ -370,13 +373,62 @@ async def test_options_flow_successful_update(self, hass: HomeAssistant, mock_co
             result = await options_flow.async_step_init(new_data)
 
         assert result["type"] == FlowResultType.CREATE_ENTRY
-        # Options flow now returns experimental_features setting
+        # Options flow returns experimental_features setting
         assert result["data"] == {"experimental_features": False}
+        # Connection data should not include experimental_features
+        expected_connection_data = {
+            CONF_HOST: "192.168.1.101",
+            CONF_ENCRYPTION_KEY: "new_key",
+            CONF_SCAN_INTERVAL: 60,
+            CONF_ADMIN_USERNAME: "admin",
+            CONF_ADMIN_PASSWORD: "password",
+        }
         hass.config_entries.async_update_entry.assert_called_once_with(
-            mock_config_entry, data=new_data
+            mock_config_entry, data=expected_connection_data
         )
         hass.config_entries.async_reload.assert_called_once_with("test_entry_id")
 
+    async def test_options_flow_with_experimental_features(self, hass: HomeAssistant, mock_config_entry):
+        """Test options flow with experimental features enabled goes to step 2."""
+        # Mock the config entries registry methods
+        hass.config_entries.async_update_entry = MagicMock()
+        hass.config_entries.async_reload = AsyncMock()
+
+        # Create options flow
+        options_flow = OptionsFlowHandler(mock_config_entry)
+        options_flow.hass = hass
+
+        new_data = {
+            CONF_HOST: "192.168.1.101",
+            CONF_ENCRYPTION_KEY: "new_key",
+            CONF_SCAN_INTERVAL: 60,
+            CONF_ADMIN_USERNAME: "admin",
+            CONF_ADMIN_PASSWORD: "password",
+            CONF_EXPERIMENTAL_FEATURES: True,
+        }
+
+        with patch(
+            "custom_components.mitsubishi.config_flow.validate_input",
+            return_value={"title": "Test Device", "unique_id": "test_mac"},
+        ):
+            result = await options_flow.async_step_init(new_data)
+
+        # Should go to experimental step
+        assert result["type"] == FlowResultType.FORM
+        assert result["step_id"] == "experimental"
+
+        # Now complete the experimental step with an entity selection
+        result2 = await options_flow.async_step_experimental({
+            CONF_EXTERNAL_TEMP_ENTITY: "sensor.room_temp"
+        })
+
+        assert result2["type"] == FlowResultType.CREATE_ENTRY
+        assert result2["data"] == {
+            "experimental_features": True,
+            "external_temperature_entity": "sensor.room_temp",
+        }
+        hass.config_entries.async_reload.assert_called_with("test_entry_id")
+
     async def test_options_flow_cannot_connect(self, hass: HomeAssistant, mock_config_entry):
         """Test options flow with connection error."""
         # Create options flow
@@ -389,6 +441,7 @@ async def test_options_flow_cannot_connect(self, hass: HomeAssistant, mock_confi
             CONF_SCAN_INTERVAL: 30,
             CONF_ADMIN_USERNAME: "admin",
             CONF_ADMIN_PASSWORD: "password",
+            CONF_EXPERIMENTAL_FEATURES: False,
         }
 
         with patch(
@@ -413,6 +466,7 @@ async def test_options_flow_unknown_error(self, hass: HomeAssistant, mock_config
             CONF_SCAN_INTERVAL: 30,
             CONF_ADMIN_USERNAME: "admin",
             CONF_ADMIN_PASSWORD: "password",
+            CONF_EXPERIMENTAL_FEATURES: False,
         }
 
         with patch(