653 lines
22 KiB
Python
653 lines
22 KiB
Python
from __future__ import annotations
|
|
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
from pytest_homeassistant_custom_component.common import MockConfigEntry
|
|
|
|
from custom_components.sws12500.const import (
|
|
API_ID,
|
|
API_KEY,
|
|
DEV_DBG,
|
|
DOMAIN,
|
|
ECOWITT_ENABLED,
|
|
ECOWITT_WEBHOOK_ID,
|
|
INVALID_CREDENTIALS,
|
|
LEGACY_ENABLED,
|
|
POCASI_CZ_API_ID,
|
|
POCASI_CZ_API_KEY,
|
|
POCASI_CZ_ENABLED,
|
|
POCASI_CZ_LOGGER_ENABLED,
|
|
POCASI_CZ_SEND_INTERVAL,
|
|
POCASI_CZ_SEND_MINIMUM,
|
|
SENSORS_TO_LOAD,
|
|
WINDY_ENABLED,
|
|
WINDY_LOGGER_ENABLED,
|
|
WINDY_STATION_ID,
|
|
WINDY_STATION_PW,
|
|
WSLINK,
|
|
WSLINK_ADDON_PORT,
|
|
)
|
|
from homeassistant import config_entries
|
|
from homeassistant.helpers.network import NoURLAvailableError
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_config_flow_user_form_then_create_entry(
|
|
hass, enable_custom_integrations
|
|
) -> None:
|
|
"""Online HA: config flow shows form then creates entry and options."""
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN, context={"source": config_entries.SOURCE_USER}
|
|
)
|
|
assert result["type"] == "menu"
|
|
assert result["step_id"] == "user"
|
|
|
|
form = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"], user_input={"next_step_id": "pws"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "pws"
|
|
|
|
user_input = {
|
|
API_ID: "my_id",
|
|
API_KEY: "my_key",
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
}
|
|
result2 = await hass.config_entries.flow.async_configure(
|
|
form["flow_id"], user_input=user_input
|
|
)
|
|
assert result2["type"] == "create_entry"
|
|
assert result2["title"] == DOMAIN
|
|
# The PWS step augments user input with legacy/ecowitt flags.
|
|
assert result2["data"][API_ID] == "my_id"
|
|
assert result2["data"][API_KEY] == "my_key"
|
|
assert result2["data"][LEGACY_ENABLED] is True
|
|
assert result2["data"][ECOWITT_ENABLED] is False
|
|
assert result2["options"] == result2["data"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_config_flow_user_invalid_credentials_api_id(
|
|
hass, enable_custom_integrations
|
|
) -> None:
|
|
"""API_ID in INVALID_CREDENTIALS -> error on API_ID."""
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN, context={"source": config_entries.SOURCE_USER}
|
|
)
|
|
assert result["type"] == "menu"
|
|
|
|
form = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"], user_input={"next_step_id": "pws"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "pws"
|
|
|
|
user_input = {
|
|
API_ID: INVALID_CREDENTIALS[0],
|
|
API_KEY: "ok_key",
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
}
|
|
result2 = await hass.config_entries.flow.async_configure(
|
|
form["flow_id"], user_input=user_input
|
|
)
|
|
assert result2["type"] == "form"
|
|
assert result2["step_id"] == "pws"
|
|
assert result2["errors"][API_ID] == "valid_credentials_api"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_config_flow_user_invalid_credentials_api_key(
|
|
hass, enable_custom_integrations
|
|
) -> None:
|
|
"""API_KEY in INVALID_CREDENTIALS -> error on API_KEY."""
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN, context={"source": config_entries.SOURCE_USER}
|
|
)
|
|
assert result["type"] == "menu"
|
|
|
|
form = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"], user_input={"next_step_id": "pws"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "pws"
|
|
|
|
user_input = {
|
|
API_ID: "ok_id",
|
|
API_KEY: INVALID_CREDENTIALS[0],
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
}
|
|
result2 = await hass.config_entries.flow.async_configure(
|
|
form["flow_id"], user_input=user_input
|
|
)
|
|
assert result2["type"] == "form"
|
|
assert result2["step_id"] == "pws"
|
|
assert result2["errors"][API_KEY] == "valid_credentials_key"
|
|
|
|
|
|
@pytest.mark.parametrize("blank", ["", " "])
|
|
@pytest.mark.parametrize("field", [API_ID, API_KEY])
|
|
@pytest.mark.asyncio
|
|
async def test_config_flow_user_rejects_blank_credentials(
|
|
hass, enable_custom_integrations, field, blank
|
|
) -> None:
|
|
"""Blank PWS credentials must not create an entry.
|
|
|
|
`INVALID_CREDENTIALS` holds placeholder strings only, so an empty (or
|
|
whitespace-only) value used to pass validation. The entry was created but
|
|
`_validate_credentials` then rejected every incoming packet, leaving the
|
|
integration permanently without data.
|
|
"""
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN, context={"source": config_entries.SOURCE_USER}
|
|
)
|
|
form = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"], user_input={"next_step_id": "pws"}
|
|
)
|
|
assert form["step_id"] == "pws"
|
|
|
|
user_input = {
|
|
API_ID: "ok_id",
|
|
API_KEY: "ok_key",
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
}
|
|
user_input[field] = blank
|
|
|
|
result2 = await hass.config_entries.flow.async_configure(
|
|
form["flow_id"], user_input=user_input
|
|
)
|
|
assert result2["type"] == "form"
|
|
assert result2["step_id"] == "pws"
|
|
expected = "valid_credentials_api" if field is API_ID else "valid_credentials_key"
|
|
assert result2["errors"][field] == expected
|
|
|
|
|
|
@pytest.mark.parametrize("blank", ["", " "])
|
|
@pytest.mark.parametrize("field", [API_ID, API_KEY])
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_basic_rejects_blank_credentials(
|
|
hass, enable_custom_integrations, field, blank
|
|
) -> None:
|
|
"""Same blank-credential rule applies when the legacy endpoint is re-enabled."""
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
data={},
|
|
options={LEGACY_ENABLED: False, ECOWITT_ENABLED: False},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
form = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input={"next_step_id": "basic"}
|
|
)
|
|
assert form["step_id"] == "basic"
|
|
|
|
user_input = {
|
|
API_ID: "ok_id",
|
|
API_KEY: "ok_key",
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
LEGACY_ENABLED: True,
|
|
}
|
|
user_input[field] = blank
|
|
|
|
result = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input=user_input
|
|
)
|
|
assert result["type"] == "form"
|
|
expected = "valid_credentials_api" if field is API_ID else "valid_credentials_key"
|
|
assert result["errors"][field] == expected
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_config_flow_user_invalid_credentials_match(
|
|
hass, enable_custom_integrations
|
|
) -> None:
|
|
"""API_KEY == API_ID -> base error."""
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN, context={"source": config_entries.SOURCE_USER}
|
|
)
|
|
assert result["type"] == "menu"
|
|
|
|
form = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"], user_input={"next_step_id": "pws"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "pws"
|
|
|
|
user_input = {
|
|
API_ID: "same",
|
|
API_KEY: "same",
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
}
|
|
result2 = await hass.config_entries.flow.async_configure(
|
|
form["flow_id"], user_input=user_input
|
|
)
|
|
assert result2["type"] == "form"
|
|
assert result2["step_id"] == "pws"
|
|
assert result2["errors"]["base"] == "valid_credentials_match"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_init_menu(hass, enable_custom_integrations) -> None:
|
|
"""Options flow shows menu with expected steps."""
|
|
entry = MockConfigEntry(domain=DOMAIN, data={}, options={})
|
|
entry.add_to_hass(hass)
|
|
|
|
result = await hass.config_entries.options.async_init(entry.entry_id)
|
|
assert result["type"] == "menu"
|
|
assert result["step_id"] == "init"
|
|
assert set(result["menu_options"]) == {"basic", "wslink_port_setup", "ecowitt", "windy", "pocasi"}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_basic_validation_and_create_entry(
|
|
hass, enable_custom_integrations
|
|
) -> None:
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
data={},
|
|
options={
|
|
API_ID: "old",
|
|
API_KEY: "oldkey",
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
assert init["type"] == "menu"
|
|
|
|
form = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input={"next_step_id": "basic"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "basic"
|
|
|
|
# Cover invalid API_ID branch in options flow basic step.
|
|
bad_api_id = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={
|
|
API_ID: INVALID_CREDENTIALS[0],
|
|
API_KEY: "ok_key",
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
},
|
|
)
|
|
assert bad_api_id["type"] == "form"
|
|
assert bad_api_id["step_id"] == "basic"
|
|
assert bad_api_id["errors"][API_ID] == "valid_credentials_api"
|
|
|
|
# Cover invalid API_KEY branch in options flow basic step.
|
|
bad_api_key = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={
|
|
API_ID: "ok_id",
|
|
API_KEY: INVALID_CREDENTIALS[0],
|
|
WSLINK: False,
|
|
DEV_DBG: False,
|
|
},
|
|
)
|
|
assert bad_api_key["type"] == "form"
|
|
assert bad_api_key["step_id"] == "basic"
|
|
assert bad_api_key["errors"][API_KEY] == "valid_credentials_key"
|
|
|
|
bad = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={API_ID: "same", API_KEY: "same", WSLINK: False, DEV_DBG: False},
|
|
)
|
|
assert bad["type"] == "form"
|
|
assert bad["step_id"] == "basic"
|
|
assert bad["errors"]["base"] == "valid_credentials_match"
|
|
|
|
good = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={API_ID: "new", API_KEY: "newkey", WSLINK: True, DEV_DBG: True},
|
|
)
|
|
assert good["type"] == "create_entry"
|
|
assert good["title"] == DOMAIN
|
|
assert good["data"][API_ID] == "new"
|
|
assert good["data"][API_KEY] == "newkey"
|
|
assert good["data"][WSLINK] is True
|
|
assert good["data"][DEV_DBG] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_windy_requires_keys_when_enabled(
|
|
hass, enable_custom_integrations
|
|
) -> None:
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
data={},
|
|
options={
|
|
WINDY_ENABLED: False,
|
|
WINDY_LOGGER_ENABLED: False,
|
|
WINDY_STATION_ID: "",
|
|
WINDY_STATION_PW: "",
|
|
},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
form = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input={"next_step_id": "windy"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "windy"
|
|
|
|
bad = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={
|
|
WINDY_ENABLED: True,
|
|
WINDY_LOGGER_ENABLED: False,
|
|
WINDY_STATION_ID: "",
|
|
WINDY_STATION_PW: "",
|
|
},
|
|
)
|
|
assert bad["type"] == "form"
|
|
assert bad["step_id"] == "windy"
|
|
assert bad["errors"][WINDY_STATION_ID] == "windy_key_required"
|
|
|
|
good = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={
|
|
WINDY_ENABLED: True,
|
|
WINDY_LOGGER_ENABLED: True,
|
|
WINDY_STATION_ID: "sid",
|
|
WINDY_STATION_PW: "spw",
|
|
},
|
|
)
|
|
assert good["type"] == "create_entry"
|
|
assert good["data"][WINDY_ENABLED] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_pocasi_validation_minimum_interval_and_required_keys(
|
|
hass,
|
|
enable_custom_integrations,
|
|
) -> None:
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
data={},
|
|
options={
|
|
POCASI_CZ_API_ID: "",
|
|
POCASI_CZ_API_KEY: "",
|
|
POCASI_CZ_ENABLED: False,
|
|
POCASI_CZ_LOGGER_ENABLED: False,
|
|
POCASI_CZ_SEND_INTERVAL: 30,
|
|
},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
form = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input={"next_step_id": "pocasi"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "pocasi"
|
|
|
|
bad = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={
|
|
POCASI_CZ_API_ID: "",
|
|
POCASI_CZ_API_KEY: "",
|
|
POCASI_CZ_ENABLED: True,
|
|
POCASI_CZ_LOGGER_ENABLED: False,
|
|
POCASI_CZ_SEND_INTERVAL: POCASI_CZ_SEND_MINIMUM - 1,
|
|
},
|
|
)
|
|
assert bad["type"] == "form"
|
|
assert bad["step_id"] == "pocasi"
|
|
assert bad["errors"][POCASI_CZ_SEND_INTERVAL] == "pocasi_send_minimum"
|
|
assert bad["errors"][POCASI_CZ_API_ID] == "pocasi_id_required"
|
|
assert bad["errors"][POCASI_CZ_API_KEY] == "pocasi_key_required"
|
|
|
|
good = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={
|
|
POCASI_CZ_API_ID: "pid",
|
|
POCASI_CZ_API_KEY: "pkey",
|
|
POCASI_CZ_ENABLED: True,
|
|
POCASI_CZ_LOGGER_ENABLED: True,
|
|
POCASI_CZ_SEND_INTERVAL: POCASI_CZ_SEND_MINIMUM,
|
|
},
|
|
)
|
|
assert good["type"] == "create_entry"
|
|
assert good["data"][POCASI_CZ_ENABLED] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_ecowitt_uses_get_url_placeholders_and_webhook_default(
|
|
hass,
|
|
enable_custom_integrations,
|
|
) -> None:
|
|
"""Online HA: ecowitt step uses get_url() placeholders and secrets token when webhook id missing."""
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
data={},
|
|
options={
|
|
ECOWITT_WEBHOOK_ID: "",
|
|
ECOWITT_ENABLED: False,
|
|
# Ecowitt can only be turned on when the legacy endpoint is off.
|
|
LEGACY_ENABLED: False,
|
|
},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
# A URL without a host degrades to the "UNKNOWN" placeholder rather than raising.
|
|
# (`yarl.URL.host` is a read-only cached property, so the fallback has to build a
|
|
# new value instead of assigning to it.) This runs in its own flow because showing
|
|
# the form advances past the menu.
|
|
hostless_init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
assert hostless_init["type"] == "menu"
|
|
|
|
with patch(
|
|
"custom_components.sws12500.config_flow.get_url",
|
|
return_value="http://",
|
|
):
|
|
hostless = await hass.config_entries.options.async_configure(
|
|
hostless_init["flow_id"], user_input={"next_step_id": "ecowitt"}
|
|
)
|
|
assert hostless["type"] == "form"
|
|
assert (hostless.get("description_placeholders") or {})["url"] == "UNKNOWN"
|
|
|
|
# A normal URL fills real placeholders and completes the flow.
|
|
init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
assert init["type"] == "menu"
|
|
|
|
with patch(
|
|
"custom_components.sws12500.config_flow.get_url",
|
|
return_value="http://example.local:8123",
|
|
):
|
|
form = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input={"next_step_id": "ecowitt"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "ecowitt"
|
|
placeholders = form.get("description_placeholders") or {}
|
|
assert placeholders["url"] == "example.local"
|
|
assert placeholders["port"] == "8123"
|
|
assert placeholders["webhook_id"] # generated
|
|
|
|
done = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={
|
|
ECOWITT_WEBHOOK_ID: placeholders["webhook_id"],
|
|
ECOWITT_ENABLED: True,
|
|
},
|
|
)
|
|
assert done["type"] == "create_entry"
|
|
assert done["data"][ECOWITT_ENABLED] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_ecowitt_survives_no_url_available(
|
|
hass, enable_custom_integrations
|
|
) -> None:
|
|
"""`get_url` raising must not abort the Ecowitt options step.
|
|
|
|
The host/port are shown as setup instructions only. HA can fail to resolve any
|
|
of its own URLs (no internal/external URL configured), and letting that escape
|
|
made the Ecowitt setup unreachable.
|
|
"""
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
data={},
|
|
options={ECOWITT_WEBHOOK_ID: "", ECOWITT_ENABLED: False, LEGACY_ENABLED: False},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
with patch(
|
|
"custom_components.sws12500.config_flow.get_url",
|
|
side_effect=NoURLAvailableError,
|
|
):
|
|
form = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input={"next_step_id": "ecowitt"}
|
|
)
|
|
assert form["type"] == "form"
|
|
placeholders = form.get("description_placeholders") or {}
|
|
assert placeholders["url"] == "UNKNOWN"
|
|
assert placeholders["port"] == "UNKNOWN"
|
|
assert placeholders["webhook_id"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_config_flow_ecowitt_survives_no_url_available(
|
|
hass, enable_custom_integrations
|
|
) -> None:
|
|
"""The initial Ecowitt step stays usable when HA cannot resolve its own URL."""
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN, context={"source": config_entries.SOURCE_USER}
|
|
)
|
|
with patch(
|
|
"custom_components.sws12500.config_flow.get_url",
|
|
side_effect=NoURLAvailableError,
|
|
):
|
|
form = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"], user_input={"next_step_id": "ecowitt"}
|
|
)
|
|
assert form["type"] == "form"
|
|
placeholders = form.get("description_placeholders") or {}
|
|
assert placeholders["url"] == "UNKNOWN"
|
|
assert placeholders["port"] == "UNKNOWN"
|
|
|
|
# The step is still completable without a resolvable URL.
|
|
done = await hass.config_entries.flow.async_configure(
|
|
form["flow_id"],
|
|
user_input={
|
|
ECOWITT_WEBHOOK_ID: placeholders["webhook_id"],
|
|
ECOWITT_ENABLED: True,
|
|
},
|
|
)
|
|
assert done["type"] == "create_entry"
|
|
assert done["data"][ECOWITT_ENABLED] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_wslink_port_setup(hass, enable_custom_integrations) -> None:
|
|
"""The WSLink add-on port step shows a form and stores the port."""
|
|
# A falsy stored port exercises the 443 default fallback.
|
|
entry = MockConfigEntry(domain=DOMAIN, data={}, options={WSLINK_ADDON_PORT: 0})
|
|
entry.add_to_hass(hass)
|
|
|
|
init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
assert init["type"] == "menu"
|
|
|
|
form = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input={"next_step_id": "wslink_port_setup"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "wslink_port_setup"
|
|
|
|
done = await hass.config_entries.options.async_configure(
|
|
init["flow_id"], user_input={WSLINK_ADDON_PORT: 8443}
|
|
)
|
|
assert done["type"] == "create_entry"
|
|
assert done["data"][WSLINK_ADDON_PORT] == 8443
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_config_flow_ecowitt_initial_setup(hass, enable_custom_integrations) -> None:
|
|
"""Initial config flow: user menu -> ecowitt step creates an Ecowitt-only entry."""
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN, context={"source": config_entries.SOURCE_USER}
|
|
)
|
|
assert result["type"] == "menu"
|
|
|
|
with patch(
|
|
"custom_components.sws12500.config_flow.get_url",
|
|
return_value="http://example.local:8123",
|
|
):
|
|
form = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"], user_input={"next_step_id": "ecowitt"}
|
|
)
|
|
assert form["type"] == "form"
|
|
assert form["step_id"] == "ecowitt"
|
|
placeholders = form.get("description_placeholders") or {}
|
|
assert placeholders["url"] == "example.local"
|
|
assert placeholders["webhook_id"]
|
|
|
|
done = await hass.config_entries.flow.async_configure(
|
|
form["flow_id"],
|
|
user_input={
|
|
ECOWITT_WEBHOOK_ID: placeholders["webhook_id"],
|
|
ECOWITT_ENABLED: True,
|
|
},
|
|
)
|
|
assert done["type"] == "create_entry"
|
|
assert done["data"][ECOWITT_ENABLED] is True
|
|
assert done["data"][LEGACY_ENABLED] is False
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_options_flow_does_not_roll_back_concurrent_autodiscovery(
|
|
hass,
|
|
enable_custom_integrations,
|
|
) -> None:
|
|
"""Auto-discovery that lands while the dialog is open must survive the submit.
|
|
|
|
The options flow snapshots the entry when a step opens, but the webhook handler
|
|
appends to SENSORS_TO_LOAD independently. Writing back the snapshot would silently
|
|
drop any sensor discovered in between.
|
|
"""
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
data={},
|
|
options={
|
|
API_ID: "station",
|
|
API_KEY: "secret",
|
|
LEGACY_ENABLED: True,
|
|
SENSORS_TO_LOAD: ["outside_temp"],
|
|
},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
init = await hass.config_entries.options.async_init(entry.entry_id)
|
|
await hass.config_entries.options.async_configure(init["flow_id"], user_input={"next_step_id": "basic"})
|
|
|
|
# The station starts reporting a new field while the form is on screen.
|
|
hass.config_entries.async_update_entry(
|
|
entry,
|
|
options={**entry.options, SENSORS_TO_LOAD: ["outside_temp", "wind_gust"]},
|
|
)
|
|
|
|
done = await hass.config_entries.options.async_configure(
|
|
init["flow_id"],
|
|
user_input={
|
|
API_ID: "station",
|
|
API_KEY: "secret",
|
|
WSLINK: False,
|
|
LEGACY_ENABLED: True,
|
|
},
|
|
)
|
|
|
|
assert done["type"] == "create_entry"
|
|
assert done["data"][SENSORS_TO_LOAD] == ["outside_temp", "wind_gust"]
|