Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update Plugwise Config Flow (#47563) 

Co-authored-by: Tom Scholten <git@scholten.nu>
pull/53101/head
Bouwe Westerdijk 2021-07-16 18:46:23 +02:00 committed by GitHub
parent 9d79c4f617
commit 669883d416
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 244 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
homeassistant/components/plugwise/config_flow.py
View File

@ -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(
{
vol.Required(
CONF_USERNAME, default="smile", description={"suggested_value": "smile"}
): str,
vol.Required(CONF_PASSWORD): str,
}
)
base_gw_schema.update({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_PORT: discovery_info.get(CONF_PORT, DEFAULT_PORT),
CONF_HOST: self.discovery_info[CONF_HOST],
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."""
# PLACEHOLDER USB vs Gateway Logic
return await self.async_step_user_gateway()
"""Handle the initial step when using network/gateway setups."""
errors = {}
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,

62
homeassistant/components/plugwise/const.py
View File

@ -1,10 +1,33 @@
"""Constant for Plugwise component."""
DOMAIN = "plugwise"
"""Constants for Plugwise component."""
SENSOR_PLATFORMS = ["sensor", "switch"]
PLATFORMS_GATEWAY = ["binary_sensor", "climate", "sensor", "switch"]
PW_TYPE = "plugwise_type"
API = "api"
ATTR_ILLUMINANCE = "illuminance"
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 = {"power": 10, "stretch": 60, "thermostat": 60}
DEFAULT_SCAN_INTERVAL = {
"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"
UNIT_LUMEN = "lm"
DEVICE_STATE = "device_state"
SCHEDULE_OFF = "false"
SCHEDULE_ON = "true"
# Icons
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",
}

185
tests/components/plugwise/test_config_flow.py
View File

@ -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",
return_value=True,
), patch(
"homeassistant.components.plugwise.config_flow.Smile",
) as smile_mock, 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["data"] == {
CONF_HOST: TEST_HOST,
CONF_PASSWORD: TEST_PASSWORD,
CONF_PORT: DEFAULT_PORT,
CONF_USERNAME: TEST_USERNAME2,
}
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
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["errors"] == {}
assert result3["type"] == RESULT_TYPE_FORM
with patch(
"homeassistant.components.plugwise.config_flow.Smile.connect",
return_value=True,
), patch(
"homeassistant.components.plugwise.config_flow.Smile",
) as smile_mock, 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,
}