jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-04-23 00:37:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove deprecated yaml import from dynalite (#130982)

Browse Source
This commit is contained in:
G Johansson 2024-11-19 20:19:30 +01:00 committed by GitHub
parent 71e8c79cad
commit c5622df386
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 59 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
homeassistant/components/dynalite/__init__.py
View File

@ -4,21 +4,17 @@ from __future__ import annotations
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant, ServiceCall
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.typing import ConfigType
# Loading the config flow file will register the flow
from .bridge import DynaliteBridge
from .const import (
ATTR_AREA,
ATTR_CHANNEL,
ATTR_HOST,
CONF_BRIDGES,
DOMAIN,
LOGGER,
PLATFORMS,
@ -27,41 +23,14 @@ from .const import (
)
from .convert_config import convert_config
from .panel import async_register_dynalite_frontend
from .schema import BRIDGE_SCHEMA
CONFIG_SCHEMA = vol.Schema(
vol.All(
cv.deprecated(DOMAIN),
{
DOMAIN: vol.Schema(
{vol.Optional(CONF_BRIDGES): vol.All(cv.ensure_list, [BRIDGE_SCHEMA])}
),
},
),
extra=vol.ALLOW_EXTRA,
)
CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up the Dynalite platform."""
conf = config.get(DOMAIN, {})
LOGGER.debug("Setting up dynalite component config = %s", conf)
hass.data[DOMAIN] = {}
bridges = conf.get(CONF_BRIDGES, [])
for bridge_conf in bridges:
host = bridge_conf[CONF_HOST]
LOGGER.debug("Starting config entry flow host=%s conf=%s", host, bridge_conf)
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data=bridge_conf,
)
)
async def dynalite_service(service_call: ServiceCall) -> None:
data = service_call.data
host = data.get(ATTR_HOST, "")

34
homeassistant/components/dynalite/config_flow.py
View File

@ -8,9 +8,7 @@ import voluptuous as vol
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
from .bridge import DynaliteBridge
from .const import DEFAULT_PORT, DOMAIN, LOGGER
@ -26,38 +24,6 @@ class DynaliteFlowHandler(ConfigFlow, domain=DOMAIN):
"""Initialize the Dynalite flow."""
self.host = None
async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
"""Import a new bridge as a config entry."""
LOGGER.debug("Starting async_step_import (deprecated) - %s", import_data)
# Raise an issue that this is deprecated and has been imported
async_create_issue(
self.hass,
HOMEASSISTANT_DOMAIN,
f"deprecated_yaml_{DOMAIN}",
breaks_in_ha_version="2023.12.0",
is_fixable=False,
is_persistent=False,
issue_domain=DOMAIN,
severity=IssueSeverity.WARNING,
translation_key="deprecated_yaml",
translation_placeholders={
"domain": DOMAIN,
"integration_title": "Dynalite",
},
)
host = import_data[CONF_HOST]
# Check if host already exists
for entry in self._async_current_entries():
if entry.data[CONF_HOST] == host:
self.hass.config_entries.async_update_entry(
entry, data=dict(import_data)
)
return self.async_abort(reason="already_configured")
# New entry
return await self._try_create(import_data)
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> ConfigFlowResult:

1
homeassistant/components/dynalite/const.py
View File

@ -16,7 +16,6 @@ ACTIVE_OFF = "off"
ACTIVE_ON = "on"
CONF_AREA = "area"
CONF_AUTO_DISCOVER = "autodiscover"
CONF_BRIDGES = "bridges"
CONF_CHANNEL = "channel"
CONF_CHANNEL_COVER = "channel_cover"
CONF_CLOSE_PRESET = "close"

4
tests/components/dynalite/common.py
View File

@ -5,7 +5,7 @@ from unittest.mock import AsyncMock, Mock, call, patch
from dynalite_devices_lib.dynalitebase import DynaliteBaseDevice
from homeassistant.components import dynalite
from homeassistant.const import ATTR_SERVICE
from homeassistant.const import ATTR_SERVICE, CONF_HOST
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry
@ -34,7 +34,7 @@ async def get_entry_id_from_hass(hass: HomeAssistant) -> str:
async def create_entity_from_device(hass: HomeAssistant, device: DynaliteBaseDevice):
"""Set up the component and platform and create a light based on the device provided."""
host = "1.2.3.4"
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host})
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={CONF_HOST: host})
entry.add_to_hass(hass)
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices"

9
tests/components/dynalite/test_bridge.py
View File

@ -17,6 +17,7 @@ from homeassistant.components.dynalite.const import (
ATTR_PACKET,
ATTR_PRESET,
)
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant
from homeassistant.helpers.dispatcher import async_dispatcher_connect
@ -26,7 +27,7 @@ from tests.common import MockConfigEntry
async def test_update_device(hass: HomeAssistant) -> None:
"""Test that update works."""
host = "1.2.3.4"
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host})
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={CONF_HOST: host})
entry.add_to_hass(hass)
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices"
@ -56,7 +57,7 @@ async def test_update_device(hass: HomeAssistant) -> None:
async def test_add_devices_then_register(hass: HomeAssistant) -> None:
"""Test that add_devices work."""
host = "1.2.3.4"
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host})
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={CONF_HOST: host})
entry.add_to_hass(hass)
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices"
@ -91,7 +92,7 @@ async def test_add_devices_then_register(hass: HomeAssistant) -> None:
async def test_register_then_add_devices(hass: HomeAssistant) -> None:
"""Test that add_devices work after register_add_entities."""
host = "1.2.3.4"
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host})
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={CONF_HOST: host})
entry.add_to_hass(hass)
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices"
@ -120,7 +121,7 @@ async def test_register_then_add_devices(hass: HomeAssistant) -> None:
async def test_notifications(hass: HomeAssistant) -> None:
"""Test that update works."""
host = "1.2.3.4"
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host})
entry = MockConfigEntry(domain=dynalite.DOMAIN, data={CONF_HOST: host})
entry.add_to_hass(hass)
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices"

61
tests/components/dynalite/test_config_flow.py
View File

@ -7,11 +7,9 @@ import pytest
from homeassistant import config_entries
from homeassistant.components import dynalite
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import CONF_PORT
from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResultType
from homeassistant.helpers import issue_registry as ir
from homeassistant.setup import async_setup_component
from tests.common import MockConfigEntry
@ -31,11 +29,8 @@ async def test_flow(
exp_type,
exp_result,
exp_reason,
issue_registry: ir.IssueRegistry,
) -> None:
"""Run a flow with or without errors and return result."""
issue = issue_registry.async_get_issue(dynalite.DOMAIN, "deprecated_yaml")
assert issue is None
host = "1.2.3.4"
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices.async_setup",
@ -43,8 +38,8 @@ async def test_flow(
):
result = await hass.config_entries.flow.async_init(
dynalite.DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={dynalite.CONF_HOST: host},
context={"source": config_entries.SOURCE_USER},
data={CONF_HOST: host},
)
await hass.async_block_till_done()
assert result["type"] == exp_type
@ -52,51 +47,33 @@ async def test_flow(
assert result["result"].state == exp_result
if exp_reason:
assert result["reason"] == exp_reason
issue = issue_registry.async_get_issue(
HOMEASSISTANT_DOMAIN, f"deprecated_yaml_{dynalite.DOMAIN}"
)
assert issue is not None
assert issue.issue_domain == dynalite.DOMAIN
assert issue.severity == ir.IssueSeverity.WARNING
async def test_deprecated(
hass: HomeAssistant, caplog: pytest.LogCaptureFixture
) -> None:
"""Check that deprecation warning appears in caplog."""
await async_setup_component(
hass, dynalite.DOMAIN, {dynalite.DOMAIN: {dynalite.CONF_HOST: "aaa"}}
)
assert "The 'dynalite' option is deprecated" in caplog.text
async def test_existing(hass: HomeAssistant) -> None:
"""Test when the entry exists with the same config."""
host = "1.2.3.4"
MockConfigEntry(
domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host}
).add_to_hass(hass)
MockConfigEntry(domain=dynalite.DOMAIN, data={CONF_HOST: host}).add_to_hass(hass)
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices.async_setup",
return_value=True,
):
result = await hass.config_entries.flow.async_init(
dynalite.DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={dynalite.CONF_HOST: host},
context={"source": config_entries.SOURCE_USER},
data={CONF_HOST: host},
)
assert result["type"] is FlowResultType.ABORT
assert result["reason"] == "already_configured"
async def test_existing_update(hass: HomeAssistant) -> None:
async def test_existing_abort_update(hass: HomeAssistant) -> None:
"""Test when the entry exists with a different config."""
host = "1.2.3.4"
port1 = 7777
port2 = 8888
entry = MockConfigEntry(
domain=dynalite.DOMAIN,
data={dynalite.CONF_HOST: host, CONF_PORT: port1},
data={CONF_HOST: host, CONF_PORT: port1},
)
entry.add_to_hass(hass)
with patch(
@ -109,12 +86,12 @@ async def test_existing_update(hass: HomeAssistant) -> None:
assert mock_dyn_dev().configure.mock_calls[0][1][0]["port"] == port1
result = await hass.config_entries.flow.async_init(
dynalite.DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={dynalite.CONF_HOST: host, CONF_PORT: port2},
context={"source": config_entries.SOURCE_USER},
data={CONF_HOST: host, CONF_PORT: port2},
)
await hass.async_block_till_done()
assert mock_dyn_dev().configure.call_count == 2
assert mock_dyn_dev().configure.mock_calls[1][1][0]["port"] == port2
assert mock_dyn_dev().configure.call_count == 1
assert mock_dyn_dev().configure.mock_calls[0][1][0]["port"] == port1
assert result["type"] is FlowResultType.ABORT
assert result["reason"] == "already_configured"
@ -123,17 +100,15 @@ async def test_two_entries(hass: HomeAssistant) -> None:
"""Test when two different entries exist with different hosts."""
host1 = "1.2.3.4"
host2 = "5.6.7.8"
MockConfigEntry(
domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host1}
).add_to_hass(hass)
MockConfigEntry(domain=dynalite.DOMAIN, data={CONF_HOST: host1}).add_to_hass(hass)
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices.async_setup",
return_value=True,
):
result = await hass.config_entries.flow.async_init(
dynalite.DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={dynalite.CONF_HOST: host2},
context={"source": config_entries.SOURCE_USER},
data={CONF_HOST: host2},
)
assert result["type"] is FlowResultType.CREATE_ENTRY
assert result["result"].state is ConfigEntryState.LOADED
@ -172,9 +147,7 @@ async def test_setup_user(hass: HomeAssistant) -> None:
async def test_setup_user_existing_host(hass: HomeAssistant) -> None:
"""Test that when we setup a host that is defined, we get an error."""
host = "3.4.5.6"
MockConfigEntry(
domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host}
).add_to_hass(hass)
MockConfigEntry(domain=dynalite.DOMAIN, data={CONF_HOST: host}).add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
dynalite.DOMAIN, context={"source": config_entries.SOURCE_USER}
)

169
tests/components/dynalite/test_init.py
View File

@ -6,7 +6,7 @@ import pytest
from voluptuous import MultipleInvalid
import homeassistant.components.dynalite.const as dynalite
from homeassistant.const import CONF_DEFAULT, CONF_HOST, CONF_NAME, CONF_PORT, CONF_ROOM
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component
@ -20,71 +20,18 @@ async def test_empty_config(hass: HomeAssistant) -> None:
assert len(hass.config_entries.async_entries(dynalite.DOMAIN)) == 0
async def test_async_setup(hass: HomeAssistant) -> None:
"""Test a successful setup with all of the different options."""
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices.async_setup",
return_value=True,
):
assert await async_setup_component(
hass,
dynalite.DOMAIN,
{
dynalite.DOMAIN: {
dynalite.CONF_BRIDGES: [
{
CONF_HOST: "1.2.3.4",
CONF_PORT: 1234,
dynalite.CONF_AUTO_DISCOVER: True,
dynalite.CONF_POLL_TIMER: 5.5,
dynalite.CONF_AREA: {
"1": {
CONF_NAME: "Name1",
dynalite.CONF_CHANNEL: {"4": {}},
dynalite.CONF_PRESET: {"7": {}},
dynalite.CONF_NO_DEFAULT: True,
},
"2": {CONF_NAME: "Name2"},
"3": {
CONF_NAME: "Name3",
dynalite.CONF_TEMPLATE: CONF_ROOM,
},
"4": {
CONF_NAME: "Name4",
dynalite.CONF_TEMPLATE: dynalite.CONF_TIME_COVER,
},
},
CONF_DEFAULT: {dynalite.CONF_FADE: 2.3},
dynalite.CONF_ACTIVE: dynalite.ACTIVE_INIT,
dynalite.CONF_PRESET: {
"5": {CONF_NAME: "pres5", dynalite.CONF_FADE: 4.5}
},
dynalite.CONF_TEMPLATE: {
CONF_ROOM: {
dynalite.CONF_ROOM_ON: 6,
dynalite.CONF_ROOM_OFF: 7,
},
dynalite.CONF_TIME_COVER: {
dynalite.CONF_OPEN_PRESET: 8,
dynalite.CONF_CLOSE_PRESET: 9,
dynalite.CONF_STOP_PRESET: 10,
dynalite.CONF_CHANNEL_COVER: 3,
dynalite.CONF_DURATION: 2.2,
dynalite.CONF_TILT_TIME: 3.3,
dynalite.CONF_DEVICE_CLASS: "awning",
},
},
}
]
}
},
)
await hass.async_block_till_done()
assert len(hass.config_entries.async_entries(dynalite.DOMAIN)) == 1
async def test_service_request_area_preset(hass: HomeAssistant) -> None:
"""Test requesting and area preset via service call."""
entry = MockConfigEntry(
domain=dynalite.DOMAIN,
data={CONF_HOST: "1.2.3.4"},
)
entry2 = MockConfigEntry(
domain=dynalite.DOMAIN,
data={CONF_HOST: "5.6.7.8"},
)
entry.add_to_hass(hass)
entry2.add_to_hass(hass)
with (
patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices.async_setup",
@ -95,20 +42,8 @@ async def test_service_request_area_preset(hass: HomeAssistant) -> None:
return_value=True,
) as mock_req_area_pres,
):
assert await async_setup_component(
hass,
dynalite.DOMAIN,
{
dynalite.DOMAIN: {
dynalite.CONF_BRIDGES: [
{CONF_HOST: "1.2.3.4"},
{CONF_HOST: "5.6.7.8"},
]
}
},
)
assert await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
assert len(hass.config_entries.async_entries(dynalite.DOMAIN)) == 2
await hass.services.async_call(
dynalite.DOMAIN,
"request_area_preset",
@ -160,6 +95,16 @@ async def test_service_request_area_preset(hass: HomeAssistant) -> None:
async def test_service_request_channel_level(hass: HomeAssistant) -> None:
"""Test requesting the level of a channel via service call."""
entry = MockConfigEntry(
domain=dynalite.DOMAIN,
data={CONF_HOST: "1.2.3.4"},
)
entry2 = MockConfigEntry(
domain=dynalite.DOMAIN,
data={CONF_HOST: "5.6.7.8"},
)
entry.add_to_hass(hass)
entry2.add_to_hass(hass)
with (
patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices.async_setup",
@ -170,21 +115,7 @@ async def test_service_request_channel_level(hass: HomeAssistant) -> None:
return_value=True,
) as mock_req_chan_lvl,
):
assert await async_setup_component(
hass,
dynalite.DOMAIN,
{
dynalite.DOMAIN: {
dynalite.CONF_BRIDGES: [
{
CONF_HOST: "1.2.3.4",
dynalite.CONF_AREA: {"7": {CONF_NAME: "test"}},
},
{CONF_HOST: "5.6.7.8"},
]
}
},
)
assert await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
assert len(hass.config_entries.async_entries(dynalite.DOMAIN)) == 2
await hass.services.async_call(
@ -212,60 +143,6 @@ async def test_service_request_channel_level(hass: HomeAssistant) -> None:
assert mock_req_chan_lvl.mock_calls == [call(4, 5), call(4, 5)]
async def test_async_setup_bad_config1(hass: HomeAssistant) -> None:
"""Test a successful with bad config on templates."""
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices.async_setup",
return_value=True,
):
assert not await async_setup_component(
hass,
dynalite.DOMAIN,
{
dynalite.DOMAIN: {
dynalite.CONF_BRIDGES: [
{
CONF_HOST: "1.2.3.4",
dynalite.CONF_AREA: {
"1": {
dynalite.CONF_TEMPLATE: dynalite.CONF_TIME_COVER,
CONF_NAME: "Name",
dynalite.CONF_ROOM_ON: 7,
}
},
}
]
}
},
)
await hass.async_block_till_done()
async def test_async_setup_bad_config2(hass: HomeAssistant) -> None:
"""Test a successful with bad config on numbers."""
host = "1.2.3.4"
with patch(
"homeassistant.components.dynalite.bridge.DynaliteDevices.async_setup",
return_value=True,
):
assert not await async_setup_component(
hass,
dynalite.DOMAIN,
{
dynalite.DOMAIN: {
dynalite.CONF_BRIDGES: [
{
CONF_HOST: host,
dynalite.CONF_AREA: {"WRONG": {CONF_NAME: "Name"}},
}
]
}
},
)
await hass.async_block_till_done()
assert len(hass.config_entries.async_entries(dynalite.DOMAIN)) == 0
async def test_unload_entry(hass: HomeAssistant) -> None:
"""Test being able to unload an entry."""
host = "1.2.3.4"

22
tests/components/dynalite/test_panel.py
View File

@ -4,7 +4,7 @@ from unittest.mock import patch
from homeassistant.components import dynalite
from homeassistant.components.cover import DEVICE_CLASSES
from homeassistant.const import CONF_PORT
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry
@ -20,7 +20,7 @@ async def test_get_config(
entry = MockConfigEntry(
domain=dynalite.DOMAIN,
data={dynalite.CONF_HOST: host, CONF_PORT: port},
data={CONF_HOST: host, CONF_PORT: port},
)
entry.add_to_hass(hass)
with patch(
@ -44,7 +44,7 @@ async def test_get_config(
result = msg["result"]
entry_id = entry.entry_id
assert result == {
"config": {entry_id: {dynalite.CONF_HOST: host, CONF_PORT: port}},
"config": {entry_id: {CONF_HOST: host, CONF_PORT: port}},
"default": {
"DEFAULT_NAME": dynalite.const.DEFAULT_NAME,
"DEFAULT_PORT": dynalite.const.DEFAULT_PORT,
@ -66,7 +66,7 @@ async def test_save_config(
entry1 = MockConfigEntry(
domain=dynalite.DOMAIN,
data={dynalite.CONF_HOST: host1, CONF_PORT: port1},
data={CONF_HOST: host1, CONF_PORT: port1},
)
entry1.add_to_hass(hass)
with patch(
@ -77,7 +77,7 @@ async def test_save_config(
await hass.async_block_till_done()
entry2 = MockConfigEntry(
domain=dynalite.DOMAIN,
data={dynalite.CONF_HOST: host2, CONF_PORT: port2},
data={CONF_HOST: host2, CONF_PORT: port2},
)
entry2.add_to_hass(hass)
with patch(
@ -94,7 +94,7 @@ async def test_save_config(
"id": 24,
"type": "dynalite/save-config",
"entry_id": entry2.entry_id,
"config": {dynalite.CONF_HOST: host3, CONF_PORT: port3},
"config": {CONF_HOST: host3, CONF_PORT: port3},
}
)
@ -103,9 +103,9 @@ async def test_save_config(
assert msg["result"] == {}
existing_entry = hass.config_entries.async_get_entry(entry1.entry_id)
assert existing_entry.data == {dynalite.CONF_HOST: host1, CONF_PORT: port1}
assert existing_entry.data == {CONF_HOST: host1, CONF_PORT: port1}
modified_entry = hass.config_entries.async_get_entry(entry2.entry_id)
assert modified_entry.data[dynalite.CONF_HOST] == host3
assert modified_entry.data[CONF_HOST] == host3
assert modified_entry.data[CONF_PORT] == port3
@ -120,7 +120,7 @@ async def test_save_config_invalid_entry(
entry = MockConfigEntry(
domain=dynalite.DOMAIN,
data={dynalite.CONF_HOST: host1, CONF_PORT: port1},
data={CONF_HOST: host1, CONF_PORT: port1},
)
entry.add_to_hass(hass)
with patch(
@ -136,7 +136,7 @@ async def test_save_config_invalid_entry(
"id": 24,
"type": "dynalite/save-config",
"entry_id": "junk",
"config": {dynalite.CONF_HOST: host2, CONF_PORT: port2},
"config": {CONF_HOST: host2, CONF_PORT: port2},
}
)
@ -145,4 +145,4 @@ async def test_save_config_invalid_entry(
assert msg["result"] == {"error": True}
existing_entry = hass.config_entries.async_get_entry(entry.entry_id)
assert existing_entry.data == {dynalite.CONF_HOST: host1, CONF_PORT: port1}
assert existing_entry.data == {CONF_HOST: host1, CONF_PORT: port1}