Update Plugwise Config Flow (#47563)

Co-authored-by: Tom Scholten <git@scholten.nu>

homeassistant/components/plugwise/config_flow.py

@@ -19,10 +19,41 @@ from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.typing import DiscoveryInfoType
 
-from .const import DEFAULT_PORT, DEFAULT_SCAN_INTERVAL, DOMAIN, ZEROCONF_MAP
+from .const import (
+    API,
+    DEFAULT_PORT,
+    DEFAULT_SCAN_INTERVAL,
+    DEFAULT_USERNAME,
+    DOMAIN,
+    FLOW_NET,
+    FLOW_SMILE,
+    FLOW_STRETCH,
+    FLOW_TYPE,
+    FLOW_USB,
+    PW_TYPE,
+    SMILE,
+    STRETCH,
+    STRETCH_USERNAME,
+    ZEROCONF_MAP,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
+CONF_MANUAL_PATH = "Enter Manually"
+
+CONNECTION_SCHEMA = vol.Schema(
+    {
+        vol.Required(FLOW_TYPE, default=FLOW_NET): vol.In(
+            {
+                FLOW_NET: f"Network: {SMILE} / {STRETCH}",
+                FLOW_USB: "USB: To be added later",
+            }
+        ),
+    },
+)
+
+# PLACEHOLDER USB connection validation
+
 
 def _base_gw_schema(discovery_info):
     """Generate base schema for gateways."""
@@ -31,22 +62,18 @@ def _base_gw_schema(discovery_info):
     if not discovery_info:
         base_gw_schema[vol.Required(CONF_HOST)] = str
         base_gw_schema[vol.Optional(CONF_PORT, default=DEFAULT_PORT)] = int
+        base_gw_schema[vol.Required(CONF_USERNAME, default=SMILE)] = vol.In(
+            {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
+        )
 
-    base_gw_schema.update(
+    base_gw_schema.update({vol.Required(CONF_PASSWORD): str})
-        {
-            vol.Required(
-                CONF_USERNAME, default="smile", description={"suggested_value": "smile"}
-            ): str,
-            vol.Required(CONF_PASSWORD): str,
-        }
-    )
 
     return vol.Schema(base_gw_schema)
 
 
 async def validate_gw_input(hass: core.HomeAssistant, data):
     """
-    Validate whether the user input allows us to connect to the gateray.
+    Validate whether the user input allows us to connect to the gateway.
 
     Data has the keys from _base_gw_schema() with values provided by the user.
     """
@@ -71,9 +98,6 @@ async def validate_gw_input(hass: core.HomeAssistant, data):
     return api
 
 
-# PLACEHOLDER USB connection validation
-
-
 class PlugwiseConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Plugwise Smile."""
 
@@ -86,32 +110,43 @@ class PlugwiseConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     async def async_step_zeroconf(self, discovery_info: DiscoveryInfoType):
         """Prepare configuration for a discovered Plugwise Smile."""
         self.discovery_info = discovery_info
+        self.discovery_info[CONF_USERNAME] = DEFAULT_USERNAME
         _properties = self.discovery_info.get("properties")
 
+        # unique_id is needed here, to be able to determine whether the discovered device is known, or not.
         unique_id = self.discovery_info.get("hostname").split(".")[0]
         await self.async_set_unique_id(unique_id)
         self._abort_if_unique_id_configured()
 
+        if DEFAULT_USERNAME not in unique_id:
+            self.discovery_info[CONF_USERNAME] = STRETCH_USERNAME
         _product = _properties.get("product", None)
         _version = _properties.get("version", "n/a")
         _name = f"{ZEROCONF_MAP.get(_product, _product)} v{_version}"
 
+        # pylint: disable=no-member # https://github.com/PyCQA/pylint/issues/3167
         self.context["title_placeholders"] = {
-            CONF_HOST: discovery_info[CONF_HOST],
+            CONF_HOST: self.discovery_info[CONF_HOST],
-            CONF_PORT: discovery_info.get(CONF_PORT, DEFAULT_PORT),
             CONF_NAME: _name,
+            CONF_PORT: self.discovery_info[CONF_PORT],
+            CONF_USERNAME: self.discovery_info[CONF_USERNAME],
         }
-        return await self.async_step_user()
+        return await self.async_step_user_gateway()
+
+    # PLACEHOLDER USB step_user
 
     async def async_step_user_gateway(self, user_input=None):
-        """Handle the initial step for gateways."""
+        """Handle the initial step when using network/gateway setups."""
+        api = None
         errors = {}
 
         if user_input is not None:
+            user_input.pop(FLOW_TYPE, None)
 
             if self.discovery_info:
                 user_input[CONF_HOST] = self.discovery_info[CONF_HOST]
-                user_input[CONF_PORT] = self.discovery_info.get(CONF_PORT, DEFAULT_PORT)
+                user_input[CONF_PORT] = self.discovery_info[CONF_PORT]
+                user_input[CONF_USERNAME] = self.discovery_info[CONF_USERNAME]
 
             self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
 
@@ -125,26 +160,36 @@ class PlugwiseConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
             except Exception:  # pylint: disable=broad-except
                 _LOGGER.exception("Unexpected exception")
                 errors[CONF_BASE] = "unknown"
+
             if not errors:
                 await self.async_set_unique_id(
                     api.smile_hostname or api.gateway_id, raise_on_progress=False
                 )
                 self._abort_if_unique_id_configured()
 
+                user_input[PW_TYPE] = API
                 return self.async_create_entry(title=api.smile_name, data=user_input)
 
         return self.async_show_form(
             step_id="user_gateway",
             data_schema=_base_gw_schema(self.discovery_info),
-            errors=errors or {},
+            errors=errors,
         )
 
-    # PLACEHOLDER USB async_step_user_usb and async_step_user_usb_manual_paht
-
     async def async_step_user(self, user_input=None):
-        """Handle the initial step."""
+        """Handle the initial step when using network/gateway setups."""
-        # PLACEHOLDER USB vs Gateway Logic
+        errors = {}
-        return await self.async_step_user_gateway()
+        if user_input is not None:
+            if user_input[FLOW_TYPE] == FLOW_NET:
+                return await self.async_step_user_gateway()
+
+            # PLACEHOLDER for USB_FLOW
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=CONNECTION_SCHEMA,
+            errors=errors,
+        )
 
     @staticmethod
     @callback
@@ -165,8 +210,9 @@ class PlugwiseOptionsFlowHandler(config_entries.OptionsFlow):
         if user_input is not None:
             return self.async_create_entry(title="", data=user_input)
 
-        api = self.hass.data[DOMAIN][self.config_entry.entry_id]["api"]
+        api = self.hass.data[DOMAIN][self.config_entry.entry_id][API]
         interval = DEFAULT_SCAN_INTERVAL[api.smile_type]
+
         data = {
             vol.Optional(
                 CONF_SCAN_INTERVAL,

homeassistant/components/plugwise/const.py

@@ -1,10 +1,33 @@
-"""Constant for Plugwise component."""
+"""Constants for Plugwise component."""
-DOMAIN = "plugwise"
 
-SENSOR_PLATFORMS = ["sensor", "switch"]
+API = "api"
-PLATFORMS_GATEWAY = ["binary_sensor", "climate", "sensor", "switch"]
+ATTR_ILLUMINANCE = "illuminance"
-PW_TYPE = "plugwise_type"
+COORDINATOR = "coordinator"
+DEVICE_STATE = "device_state"
+DOMAIN = "plugwise"
+FLOW_NET = "flow_network"
+FLOW_SMILE = "smile (Adam/Anna/P1)"
+FLOW_STRETCH = "stretch (Stretch)"
+FLOW_TYPE = "flow_type"
+FLOW_USB = "flow_usb"
 GATEWAY = "gateway"
+PW_TYPE = "plugwise_type"
+SCHEDULE_OFF = "false"
+SCHEDULE_ON = "true"
+SMILE = "smile"
+STRETCH = "stretch"
+STRETCH_USERNAME = "stretch"
+UNDO_UPDATE_LISTENER = "undo_update_listener"
+UNIT_LUMEN = "lm"
+
+PLATFORMS_GATEWAY = ["binary_sensor", "climate", "sensor", "switch"]
+SENSOR_PLATFORMS = ["sensor", "switch"]
+ZEROCONF_MAP = {
+    "smile": "P1",
+    "smile_thermo": "Anna",
+    "smile_open_therm": "Adam",
+    "stretch": "Stretch",
+}
 
 # Sensor mapping
 SENSOR_MAP_DEVICE_CLASS = 2
@@ -13,13 +36,17 @@ SENSOR_MAP_MODEL = 0
 SENSOR_MAP_UOM = 1
 
 # Default directives
-DEFAULT_MIN_TEMP = 4
 DEFAULT_MAX_TEMP = 30
+DEFAULT_MIN_TEMP = 4
 DEFAULT_NAME = "Smile"
 DEFAULT_PORT = 80
-DEFAULT_USERNAME = "smile"
+DEFAULT_SCAN_INTERVAL = {
-DEFAULT_SCAN_INTERVAL = {"power": 10, "stretch": 60, "thermostat": 60}
+    "power": 10,
+    "stretch": 60,
+    "thermostat": 60,
+}
 DEFAULT_TIMEOUT = 60
+DEFAULT_USERNAME = "smile"
 
 # Configuration directives
 CONF_GAS = "gas"
@@ -28,15 +55,7 @@ CONF_MIN_TEMP = "min_temp"
 CONF_POWER = "power"
 CONF_THERMOSTAT = "thermostat"
 
-ATTR_ILLUMINANCE = "illuminance"
+# Icons
-
-UNIT_LUMEN = "lm"
-
-DEVICE_STATE = "device_state"
-
-SCHEDULE_OFF = "false"
-SCHEDULE_ON = "true"
-
 COOL_ICON = "mdi:snowflake"
 FLAME_ICON = "mdi:fire"
 FLOW_OFF_ICON = "mdi:water-pump-off"
@@ -45,12 +64,3 @@ IDLE_ICON = "mdi:circle-off-outline"
 SWITCH_ICON = "mdi:electric-switch"
 NO_NOTIFICATION_ICON = "mdi:mailbox-outline"
 NOTIFICATION_ICON = "mdi:mailbox-up-outline"
-
-COORDINATOR = "coordinator"
-UNDO_UPDATE_LISTENER = "undo_update_listener"
-ZEROCONF_MAP = {
-    "smile": "P1",
-    "smile_thermo": "Anna",
-    "smile_open_therm": "Adam",
-    "stretch": "Stretch",
-}

tests/components/plugwise/test_config_flow.py

@@ -1,5 +1,5 @@
 """Test the Plugwise config flow."""
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 from plugwise.exceptions import (
     ConnectionFailedError,
@@ -8,11 +8,15 @@ from plugwise.exceptions import (
 )
 import pytest
 
-from homeassistant import config_entries, data_entry_flow, setup
+from homeassistant import setup
 from homeassistant.components.plugwise.const import (
+    API,
     DEFAULT_PORT,
     DEFAULT_SCAN_INTERVAL,
     DOMAIN,
+    FLOW_NET,
+    FLOW_TYPE,
+    PW_TYPE,
 )
 from homeassistant.config_entries import SOURCE_USER, SOURCE_ZEROCONF
 from homeassistant.const import (
@@ -21,13 +25,16 @@ from homeassistant.const import (
     CONF_PASSWORD,
     CONF_PORT,
     CONF_SCAN_INTERVAL,
+    CONF_SOURCE,
     CONF_USERNAME,
 )
+from homeassistant.data_entry_flow import RESULT_TYPE_CREATE_ENTRY, RESULT_TYPE_FORM
 
 from tests.common import MockConfigEntry
 
 TEST_HOST = "1.1.1.1"
 TEST_HOSTNAME = "smileabcdef"
+TEST_HOSTNAME2 = "stretchabc"
 TEST_PASSWORD = "test_password"
 TEST_PORT = 81
 TEST_USERNAME = "smile"
@@ -44,6 +51,17 @@ TEST_DISCOVERY = {
         "hostname": f"{TEST_HOSTNAME}.local.",
     },
 }
+TEST_DISCOVERY2 = {
+    "host": TEST_HOST,
+    "port": DEFAULT_PORT,
+    "hostname": f"{TEST_HOSTNAME2}.local.",
+    "server": f"{TEST_HOSTNAME2}.local.",
+    "properties": {
+        "product": "stretch",
+        "version": "1.2.3",
+        "hostname": f"{TEST_HOSTNAME2}.local.",
+    },
+}
 
 
 @pytest.fixture(name="mock_smile")
@@ -52,20 +70,38 @@ def mock_smile():
     with patch(
         "homeassistant.components.plugwise.config_flow.Smile",
     ) as smile_mock:
-        smile_mock.PlugwiseError = PlugwiseException
+        smile_mock.PlugwiseException = PlugwiseException
         smile_mock.InvalidAuthentication = InvalidAuthentication
         smile_mock.ConnectionFailedError = ConnectionFailedError
         smile_mock.return_value.connect.return_value = True
         yield smile_mock.return_value
 
 
+async def test_form_flow_gateway(hass):
+    """Test we get the form for Plugwise Gateway product type."""
+    await setup.async_setup_component(hass, "persistent_notification", {})
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={CONF_SOURCE: SOURCE_USER}
+    )
+    assert result["type"] == RESULT_TYPE_FORM
+    assert result["errors"] == {}
+    assert result["step_id"] == "user"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={FLOW_TYPE: FLOW_NET}
+    )
+    assert result["type"] == RESULT_TYPE_FORM
+    assert result["errors"] == {}
+    assert result["step_id"] == "user_gateway"
+
+
 async def test_form(hass):
     """Test we get the form."""
     await setup.async_setup_component(hass, "persistent_notification", {})
     result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={CONF_SOURCE: SOURCE_USER}, data={FLOW_TYPE: FLOW_NET}
     )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result["type"] == RESULT_TYPE_FORM
     assert result["errors"] == {}
 
     with patch(
@@ -77,17 +113,18 @@ async def test_form(hass):
     ) as mock_setup_entry:
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
-            {CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD},
+            user_input={CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD},
         )
 
     await hass.async_block_till_done()
 
-    assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
+    assert result2["type"] == RESULT_TYPE_CREATE_ENTRY
     assert result2["data"] == {
         CONF_HOST: TEST_HOST,
         CONF_PASSWORD: TEST_PASSWORD,
         CONF_PORT: DEFAULT_PORT,
         CONF_USERNAME: TEST_USERNAME,
+        PW_TYPE: API,
     }
 
     assert len(mock_setup_entry.mock_calls) == 1
@@ -98,10 +135,10 @@ async def test_zeroconf_form(hass):
     await setup.async_setup_component(hass, "persistent_notification", {})
     result = await hass.config_entries.flow.async_init(
         DOMAIN,
-        context={"source": SOURCE_ZEROCONF},
+        context={CONF_SOURCE: SOURCE_ZEROCONF},
         data=TEST_DISCOVERY,
     )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result["type"] == RESULT_TYPE_FORM
     assert result["errors"] == {}
 
     with patch(
@@ -113,17 +150,55 @@ async def test_zeroconf_form(hass):
     ) as mock_setup_entry:
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
-            {CONF_PASSWORD: TEST_PASSWORD},
+            user_input={CONF_PASSWORD: TEST_PASSWORD},
         )
 
     await hass.async_block_till_done()
 
-    assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
+    assert result2["type"] == RESULT_TYPE_CREATE_ENTRY
     assert result2["data"] == {
         CONF_HOST: TEST_HOST,
         CONF_PASSWORD: TEST_PASSWORD,
         CONF_PORT: DEFAULT_PORT,
         CONF_USERNAME: TEST_USERNAME,
+        PW_TYPE: API,
+    }
+
+    assert len(mock_setup_entry.mock_calls) == 1
+
+
+async def test_zeroconf_stretch_form(hass):
+    """Test we get the form."""
+    await setup.async_setup_component(hass, "persistent_notification", {})
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={CONF_SOURCE: SOURCE_ZEROCONF},
+        data=TEST_DISCOVERY2,
+    )
+    assert result["type"] == RESULT_TYPE_FORM
+    assert result["errors"] == {}
+
+    with patch(
+        "homeassistant.components.plugwise.config_flow.Smile.connect",
+        return_value=True,
+    ), patch(
+        "homeassistant.components.plugwise.async_setup_entry",
+        return_value=True,
+    ) as mock_setup_entry:
+        result2 = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            user_input={CONF_PASSWORD: TEST_PASSWORD},
+        )
+
+    await hass.async_block_till_done()
+
+    assert result2["type"] == RESULT_TYPE_CREATE_ENTRY
+    assert result2["data"] == {
+        CONF_HOST: TEST_HOST,
+        CONF_PASSWORD: TEST_PASSWORD,
+        CONF_PORT: DEFAULT_PORT,
+        CONF_USERNAME: TEST_USERNAME2,
+        PW_TYPE: API,
     }
 
     assert len(mock_setup_entry.mock_calls) == 1
@@ -131,58 +206,68 @@ async def test_zeroconf_form(hass):
 
 async def test_form_username(hass):
     """Test we get the username data back."""
+    await setup.async_setup_component(hass, "persistent_notification", {})
     result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={CONF_SOURCE: SOURCE_USER}, data={FLOW_TYPE: FLOW_NET}
     )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result["type"] == RESULT_TYPE_FORM
     assert result["errors"] == {}
 
     with patch(
-        "homeassistant.components.plugwise.config_flow.Smile.connect",
+        "homeassistant.components.plugwise.config_flow.Smile",
-        return_value=True,
+    ) as smile_mock, patch(
-    ), patch(
         "homeassistant.components.plugwise.async_setup_entry",
         return_value=True,
     ) as mock_setup_entry:
+        smile_mock.return_value.connect.side_effect = AsyncMock(return_value=True)
+        smile_mock.return_value.gateway_id = "abcdefgh12345678"
+        smile_mock.return_value.smile_hostname = TEST_HOST
+        smile_mock.return_value.smile_name = "Adam"
+
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
-            {
+            user_input={
                 CONF_HOST: TEST_HOST,
                 CONF_PASSWORD: TEST_PASSWORD,
                 CONF_USERNAME: TEST_USERNAME2,
             },
         )
 
-    await hass.async_block_till_done()
+        await hass.async_block_till_done()
 
-    assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
+        assert result2["type"] == RESULT_TYPE_CREATE_ENTRY
-    assert result2["data"] == {
+        assert result2["data"] == {
-        CONF_HOST: TEST_HOST,
+            CONF_HOST: TEST_HOST,
-        CONF_PASSWORD: TEST_PASSWORD,
+            CONF_PASSWORD: TEST_PASSWORD,
-        CONF_PORT: DEFAULT_PORT,
+            CONF_PORT: DEFAULT_PORT,
-        CONF_USERNAME: TEST_USERNAME2,
+            CONF_USERNAME: TEST_USERNAME2,
-    }
+            PW_TYPE: API,
+        }
 
     assert len(mock_setup_entry.mock_calls) == 1
 
     result3 = await hass.config_entries.flow.async_init(
         DOMAIN,
-        context={"source": SOURCE_ZEROCONF},
+        context={CONF_SOURCE: SOURCE_ZEROCONF},
         data=TEST_DISCOVERY,
     )
-    assert result3["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result3["type"] == RESULT_TYPE_FORM
-    assert result3["errors"] == {}
 
     with patch(
-        "homeassistant.components.plugwise.config_flow.Smile.connect",
+        "homeassistant.components.plugwise.config_flow.Smile",
-        return_value=True,
+    ) as smile_mock, patch(
-    ), patch(
         "homeassistant.components.plugwise.async_setup_entry",
         return_value=True,
     ) as mock_setup_entry:
+        smile_mock.return_value.side_effect = AsyncMock(return_value=True)
+        smile_mock.return_value.connect.side_effect = AsyncMock(return_value=True)
+        smile_mock.return_value.gateway_id = "abcdefgh12345678"
+        smile_mock.return_value.smile_hostname = TEST_HOST
+        smile_mock.return_value.smile_name = "Adam"
+
         result4 = await hass.config_entries.flow.async_configure(
             result3["flow_id"],
-            {CONF_PASSWORD: TEST_PASSWORD},
+            user_input={CONF_PASSWORD: TEST_PASSWORD},
         )
 
     await hass.async_block_till_done()
@@ -194,7 +279,7 @@ async def test_form_username(hass):
 async def test_form_invalid_auth(hass, mock_smile):
     """Test we handle invalid auth."""
     result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={CONF_SOURCE: SOURCE_USER}, data={FLOW_TYPE: FLOW_NET}
     )
 
     mock_smile.connect.side_effect = InvalidAuthentication
@@ -202,17 +287,17 @@ async def test_form_invalid_auth(hass, mock_smile):
 
     result2 = await hass.config_entries.flow.async_configure(
         result["flow_id"],
-        {CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD},
+        user_input={CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD},
     )
 
-    assert result2["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result2["type"] == RESULT_TYPE_FORM
     assert result2["errors"] == {"base": "invalid_auth"}
 
 
 async def test_form_cannot_connect(hass, mock_smile):
     """Test we handle cannot connect error."""
     result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={CONF_SOURCE: SOURCE_USER}, data={FLOW_TYPE: FLOW_NET}
     )
 
     mock_smile.connect.side_effect = ConnectionFailedError
@@ -220,17 +305,17 @@ async def test_form_cannot_connect(hass, mock_smile):
 
     result2 = await hass.config_entries.flow.async_configure(
         result["flow_id"],
-        {CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD},
+        user_input={CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD},
     )
 
-    assert result2["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result2["type"] == RESULT_TYPE_FORM
     assert result2["errors"] == {"base": "cannot_connect"}
 
 
 async def test_form_cannot_connect_port(hass, mock_smile):
     """Test we handle cannot connect to port error."""
     result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={CONF_SOURCE: SOURCE_USER}, data={FLOW_TYPE: FLOW_NET}
     )
 
     mock_smile.connect.side_effect = ConnectionFailedError
@@ -238,17 +323,21 @@ async def test_form_cannot_connect_port(hass, mock_smile):
 
     result2 = await hass.config_entries.flow.async_configure(
         result["flow_id"],
-        {CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD, CONF_PORT: TEST_PORT},
+        user_input={
+            CONF_HOST: TEST_HOST,
+            CONF_PASSWORD: TEST_PASSWORD,
+            CONF_PORT: TEST_PORT,
+        },
     )
 
-    assert result2["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result2["type"] == RESULT_TYPE_FORM
     assert result2["errors"] == {"base": "cannot_connect"}
 
 
 async def test_form_other_problem(hass, mock_smile):
     """Test we handle cannot connect error."""
     result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={CONF_SOURCE: SOURCE_USER}, data={FLOW_TYPE: FLOW_NET}
     )
 
     mock_smile.connect.side_effect = TimeoutError
@@ -256,10 +345,10 @@ async def test_form_other_problem(hass, mock_smile):
 
     result2 = await hass.config_entries.flow.async_configure(
         result["flow_id"],
-        {CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD},
+        user_input={CONF_HOST: TEST_HOST, CONF_PASSWORD: TEST_PASSWORD},
     )
 
-    assert result2["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result2["type"] == RESULT_TYPE_FORM
     assert result2["errors"] == {"base": "unknown"}
 
 
@@ -283,13 +372,13 @@ async def test_options_flow_power(hass, mock_smile) -> None:
 
         result = await hass.config_entries.options.async_init(entry.entry_id)
 
-        assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+        assert result["type"] == RESULT_TYPE_FORM
         assert result["step_id"] == "init"
 
         result = await hass.config_entries.options.async_configure(
             result["flow_id"], user_input={CONF_SCAN_INTERVAL: 10}
         )
-        assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
+        assert result["type"] == RESULT_TYPE_CREATE_ENTRY
         assert result["data"] == {
             CONF_SCAN_INTERVAL: 10,
         }
@@ -315,14 +404,14 @@ async def test_options_flow_thermo(hass, mock_smile) -> None:
 
         result = await hass.config_entries.options.async_init(entry.entry_id)
 
-        assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+        assert result["type"] == RESULT_TYPE_FORM
         assert result["step_id"] == "init"
 
         result = await hass.config_entries.options.async_configure(
             result["flow_id"], user_input={CONF_SCAN_INTERVAL: 60}
         )
 
-        assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
+        assert result["type"] == RESULT_TYPE_CREATE_ENTRY
         assert result["data"] == {
             CONF_SCAN_INTERVAL: 60,
         }