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

Remove deprecated YAML import for here_travel_time (#77959)

Browse Source
This commit is contained in:
Kevin Stillhammer 2022-09-26 17:10:16 +02:00 committed by GitHub
parent 2a94c42cea
commit de3be96bdb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 12 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

117
homeassistant/components/here_travel_time/config_flow.py
View File

@ -10,7 +10,6 @@ import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import (
CONF_API_KEY,
CONF_ENTITY_NAMESPACE,
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_MODE,
@ -27,19 +26,22 @@ from homeassistant.helpers.selector import (
)
from .const import (
CONF_ARRIVAL,
CONF_ARRIVAL_TIME,
CONF_DEPARTURE,
CONF_DEPARTURE_TIME,
CONF_DESTINATION,
CONF_DESTINATION_ENTITY_ID,
CONF_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE,
CONF_ORIGIN,
CONF_ORIGIN_ENTITY_ID,
CONF_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE,
CONF_ROUTE_MODE,
CONF_TRAFFIC_MODE,
DEFAULT_NAME,
DOMAIN,
ROUTE_MODE_FASTEST,
ROUTE_MODES,
TRAFFIC_MODE_DISABLED,
TRAFFIC_MODE_ENABLED,
TRAFFIC_MODES,
TRAVEL_MODE_CAR,
@ -47,57 +49,10 @@ from .const import (
TRAVEL_MODES,
UNITS,
)
from .sensor import (
CONF_DESTINATION_ENTITY_ID,
CONF_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE,
CONF_ORIGIN_ENTITY_ID,
CONF_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE,
)
_LOGGER = logging.getLogger(__name__)
def is_dupe_import(
entry: config_entries.ConfigEntry,
user_input: dict[str, Any],
options: dict[str, Any],
) -> bool:
"""Return whether imported config already exists."""
# Check the main data keys
if any(
user_input[key] != entry.data[key]
for key in (CONF_API_KEY, CONF_MODE, CONF_NAME)
):
return False
# Check origin/destination
for key in (
CONF_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE,
CONF_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE,
CONF_DESTINATION_ENTITY_ID,
CONF_ORIGIN_ENTITY_ID,
):
if user_input.get(key) != entry.data.get(key):
return False
# We have to check for options that don't have defaults
for key in (
CONF_TRAFFIC_MODE,
CONF_UNIT_SYSTEM,
CONF_ROUTE_MODE,
CONF_ARRIVAL_TIME,
CONF_DEPARTURE_TIME,
):
if options.get(key) != entry.options.get(key):
return False
return True
def validate_api_key(api_key: str) -> None:
"""Validate the user input allows us to connect."""
known_working_origin = [38.9, -77.04833]
@ -275,66 +230,6 @@ class HERETravelTimeConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
return self.async_show_form(step_id="destination_entity", data_schema=schema)
async def async_step_import(self, user_input: dict[str, Any]) -> FlowResult:
"""Import from configuration.yaml."""
options: dict[str, Any] = {}
user_input, options = self._transform_import_input(user_input)
# We need to prevent duplicate imports
if any(
is_dupe_import(entry, user_input, options)
for entry in self.hass.config_entries.async_entries(DOMAIN)
if entry.source == config_entries.SOURCE_IMPORT
):
return self.async_abort(reason="already_configured")
return self.async_create_entry(
title=user_input[CONF_NAME], data=user_input, options=options
)
def _transform_import_input(
self, import_input: dict[str, Any]
) -> tuple[dict[str, Any], dict[str, Any]]:
"""Transform platform schema input to new model."""
options: dict[str, Any] = {}
user_input: dict[str, Any] = {}
if import_input.get(CONF_ORIGIN_LATITUDE) is not None:
user_input[CONF_ORIGIN_LATITUDE] = import_input[CONF_ORIGIN_LATITUDE]
user_input[CONF_ORIGIN_LONGITUDE] = import_input[CONF_ORIGIN_LONGITUDE]
else:
user_input[CONF_ORIGIN_ENTITY_ID] = import_input[CONF_ORIGIN_ENTITY_ID]
if import_input.get(CONF_DESTINATION_LATITUDE) is not None:
user_input[CONF_DESTINATION_LATITUDE] = import_input[
CONF_DESTINATION_LATITUDE
]
user_input[CONF_DESTINATION_LONGITUDE] = import_input[
CONF_DESTINATION_LONGITUDE
]
else:
user_input[CONF_DESTINATION_ENTITY_ID] = import_input[
CONF_DESTINATION_ENTITY_ID
]
user_input[CONF_API_KEY] = import_input[CONF_API_KEY]
user_input[CONF_MODE] = import_input[CONF_MODE]
user_input[CONF_NAME] = import_input[CONF_NAME]
if (namespace := import_input.get(CONF_ENTITY_NAMESPACE)) is not None:
user_input[CONF_NAME] = f"{namespace} {user_input[CONF_NAME]}"
options[CONF_TRAFFIC_MODE] = (
TRAFFIC_MODE_ENABLED
if import_input.get(CONF_TRAFFIC_MODE, False)
else TRAFFIC_MODE_DISABLED
)
options[CONF_ROUTE_MODE] = import_input.get(CONF_ROUTE_MODE)
options[CONF_UNIT_SYSTEM] = import_input.get(
CONF_UNIT_SYSTEM, self.hass.config.units.name
)
options[CONF_ARRIVAL_TIME] = import_input.get(CONF_ARRIVAL, None)
options[CONF_DEPARTURE_TIME] = import_input.get(CONF_DEPARTURE, None)
return user_input, options
class HERETravelTimeOptionsFlow(config_entries.OptionsFlow):
"""Handle HERE Travel Time options."""

102
homeassistant/components/here_travel_time/sensor.py
View File

@ -3,38 +3,30 @@ from __future__ import annotations
from collections.abc import Mapping
from datetime import timedelta
import logging
from typing import Any
import voluptuous as vol
from homeassistant.components.sensor import (
PLATFORM_SCHEMA,
SensorEntity,
SensorEntityDescription,
SensorStateClass,
)
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_LATITUDE,
ATTR_LONGITUDE,
CONF_API_KEY,
CONF_MODE,
CONF_NAME,
CONF_UNIT_SYSTEM,
CONF_UNIT_SYSTEM_IMPERIAL,
LENGTH_KILOMETERS,
LENGTH_MILES,
TIME_MINUTES,
)
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.device_registry import DeviceEntryType
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.start import async_at_start
from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from . import HereTravelTimeDataUpdateCoordinator
@ -47,83 +39,13 @@ from .const import (
ATTR_ORIGIN,
ATTR_ORIGIN_NAME,
ATTR_ROUTE,
CONF_ARRIVAL,
CONF_DEPARTURE,
CONF_DESTINATION_ENTITY_ID,
CONF_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE,
CONF_ORIGIN_ENTITY_ID,
CONF_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE,
CONF_ROUTE_MODE,
CONF_TRAFFIC_MODE,
DEFAULT_NAME,
DOMAIN,
ICON_CAR,
ICONS,
ROUTE_MODE_FASTEST,
ROUTE_MODES,
TRAVEL_MODE_BICYCLE,
TRAVEL_MODE_CAR,
TRAVEL_MODE_PEDESTRIAN,
TRAVEL_MODE_PUBLIC,
TRAVEL_MODE_PUBLIC_TIME_TABLE,
TRAVEL_MODE_TRUCK,
TRAVEL_MODES,
UNITS,
)
_LOGGER = logging.getLogger(__name__)
SCAN_INTERVAL = timedelta(minutes=5)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_API_KEY): cv.string,
vol.Inclusive(
CONF_DESTINATION_LATITUDE, "destination_coordinates"
): cv.latitude,
vol.Inclusive(
CONF_DESTINATION_LONGITUDE, "destination_coordinates"
): cv.longitude,
vol.Exclusive(CONF_DESTINATION_LATITUDE, "destination"): cv.latitude,
vol.Exclusive(CONF_DESTINATION_ENTITY_ID, "destination"): cv.entity_id,
vol.Inclusive(CONF_ORIGIN_LATITUDE, "origin_coordinates"): cv.latitude,
vol.Inclusive(CONF_ORIGIN_LONGITUDE, "origin_coordinates"): cv.longitude,
vol.Exclusive(CONF_ORIGIN_LATITUDE, "origin"): cv.latitude,
vol.Exclusive(CONF_ORIGIN_ENTITY_ID, "origin"): cv.entity_id,
vol.Optional(CONF_DEPARTURE): cv.time,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_MODE, default=TRAVEL_MODE_CAR): vol.In(TRAVEL_MODES),
vol.Optional(CONF_ROUTE_MODE, default=ROUTE_MODE_FASTEST): vol.In(ROUTE_MODES),
vol.Optional(CONF_TRAFFIC_MODE, default=False): cv.boolean,
vol.Optional(CONF_UNIT_SYSTEM): vol.In(UNITS),
}
)
PLATFORM_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_DESTINATION_LATITUDE, CONF_DESTINATION_ENTITY_ID),
cv.has_at_least_one_key(CONF_ORIGIN_LATITUDE, CONF_ORIGIN_ENTITY_ID),
cv.key_value_schemas(
CONF_MODE,
{
None: PLATFORM_SCHEMA,
TRAVEL_MODE_BICYCLE: PLATFORM_SCHEMA,
TRAVEL_MODE_CAR: PLATFORM_SCHEMA,
TRAVEL_MODE_PEDESTRIAN: PLATFORM_SCHEMA,
TRAVEL_MODE_PUBLIC: PLATFORM_SCHEMA,
TRAVEL_MODE_TRUCK: PLATFORM_SCHEMA,
TRAVEL_MODE_PUBLIC_TIME_TABLE: PLATFORM_SCHEMA.extend(
{
vol.Exclusive(CONF_ARRIVAL, "arrival_departure"): cv.time,
vol.Exclusive(CONF_DEPARTURE, "arrival_departure"): cv.time,
}
),
},
),
)
def sensor_descriptions(travel_mode: str) -> tuple[SensorEntityDescription, ...]:
"""Construct SensorEntityDescriptions."""
@ -150,28 +72,6 @@ def sensor_descriptions(travel_mode: str) -> tuple[SensorEntityDescription, ...]
)
async def async_setup_platform(
hass: HomeAssistant,
config: ConfigType,
async_add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
"""Set up the HERE travel time platform."""
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_IMPORT},
data=config,
)
)
_LOGGER.warning(
"Your HERE travel time configuration has been imported into the UI; "
"please remove it from configuration.yaml as support for it will be "
"removed in a future release"
)
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,

208
tests/components/here_travel_time/test_config_flow.py
View File

@ -7,10 +7,13 @@ import pytest
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.here_travel_time.const import (
CONF_ARRIVAL,
CONF_ARRIVAL_TIME,
CONF_DEPARTURE,
CONF_DEPARTURE_TIME,
CONF_DESTINATION_ENTITY_ID,
CONF_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE,
CONF_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE,
CONF_ROUTE_MODE,
CONF_TRAFFIC_MODE,
DOMAIN,
@ -19,20 +22,10 @@ from homeassistant.components.here_travel_time.const import (
TRAVEL_MODE_CAR,
TRAVEL_MODE_PUBLIC_TIME_TABLE,
)
from homeassistant.components.here_travel_time.sensor import (
CONF_DESTINATION_ENTITY_ID,
CONF_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE,
CONF_ORIGIN_ENTITY_ID,
CONF_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE,
)
from homeassistant.const import (
CONF_API_KEY,
CONF_ENTITY_NAMESPACE,
CONF_MODE,
CONF_NAME,
CONF_SCAN_INTERVAL,
CONF_UNIT_SYSTEM,
CONF_UNIT_SYSTEM_IMPERIAL,
CONF_UNIT_SYSTEM_METRIC,
@ -412,194 +405,3 @@ async def test_options_flow_no_time_step(
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
}
@pytest.mark.usefixtures("valid_response")
async def test_import_flow_entity_id(hass: HomeAssistant) -> None:
"""Test import_flow with entity ids."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_ENTITY_ID: "sensor.origin",
CONF_DESTINATION_ENTITY_ID: "sensor.destination",
CONF_NAME: "test_name",
CONF_MODE: TRAVEL_MODE_CAR,
CONF_DEPARTURE: "08:00:00",
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_IMPERIAL,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
CONF_ENTITY_NAMESPACE: "namespace",
CONF_SCAN_INTERVAL: 2678400,
},
)
await hass.async_block_till_done()
assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
assert result["title"] == "namespace test_name"
entry = hass.config_entries.async_entries(DOMAIN)[0]
assert entry.data == {
CONF_NAME: "namespace test_name",
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_ENTITY_ID: "sensor.origin",
CONF_DESTINATION_ENTITY_ID: "sensor.destination",
CONF_MODE: TRAVEL_MODE_CAR,
}
assert entry.options == {
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_IMPERIAL,
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
CONF_DEPARTURE_TIME: "08:00:00",
CONF_ARRIVAL_TIME: None,
}
@pytest.mark.usefixtures("valid_response")
async def test_import_flow_coordinates(hass: HomeAssistant) -> None:
"""Test import_flow with coordinates."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_LATITUDE: CAR_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE: CAR_ORIGIN_LONGITUDE,
CONF_DESTINATION_LATITUDE: CAR_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE: CAR_DESTINATION_LONGITUDE,
CONF_NAME: "test_name",
CONF_MODE: TRAVEL_MODE_CAR,
CONF_ARRIVAL: "08:00:00",
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
},
)
await hass.async_block_till_done()
assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
assert result["title"] == "test_name"
entry = hass.config_entries.async_entries(DOMAIN)[0]
assert entry.data == {
CONF_NAME: "test_name",
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_LATITUDE: CAR_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE: CAR_ORIGIN_LONGITUDE,
CONF_DESTINATION_LATITUDE: CAR_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE: CAR_DESTINATION_LONGITUDE,
CONF_MODE: TRAVEL_MODE_CAR,
}
assert entry.options == {
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC,
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
CONF_DEPARTURE_TIME: None,
CONF_ARRIVAL_TIME: "08:00:00",
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC,
}
@pytest.mark.usefixtures("valid_response")
async def test_dupe_import(hass: HomeAssistant) -> None:
"""Test duplicate import."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_LATITUDE: CAR_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE: CAR_ORIGIN_LONGITUDE,
CONF_DESTINATION_LATITUDE: CAR_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE: CAR_DESTINATION_LONGITUDE,
CONF_NAME: "test_name",
CONF_MODE: TRAVEL_MODE_CAR,
CONF_ARRIVAL: "08:00:00",
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
},
)
assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
await hass.async_block_till_done()
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_LATITUDE: CAR_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE: CAR_ORIGIN_LONGITUDE,
CONF_DESTINATION_LATITUDE: CAR_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE: CAR_DESTINATION_LONGITUDE,
CONF_NAME: "test_name2",
CONF_MODE: TRAVEL_MODE_CAR,
CONF_ARRIVAL: "08:00:00",
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
},
)
assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
await hass.async_block_till_done()
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_LATITUDE: CAR_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE: CAR_ORIGIN_LONGITUDE,
CONF_DESTINATION_LATITUDE: CAR_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE: CAR_DESTINATION_LONGITUDE,
CONF_NAME: "test_name",
CONF_MODE: TRAVEL_MODE_CAR,
CONF_ARRIVAL: "08:00:01",
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
},
)
assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
await hass.async_block_till_done()
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_LATITUDE: CAR_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE: CAR_ORIGIN_LONGITUDE,
CONF_DESTINATION_LATITUDE: "40.0",
CONF_DESTINATION_LONGITUDE: CAR_DESTINATION_LONGITUDE,
CONF_NAME: "test_name",
CONF_MODE: TRAVEL_MODE_CAR,
CONF_ARRIVAL: "08:00:01",
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
},
)
assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
await hass.async_block_till_done()
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={
CONF_API_KEY: CONF_API_KEY,
CONF_ORIGIN_LATITUDE: CAR_ORIGIN_LATITUDE,
CONF_ORIGIN_LONGITUDE: CAR_ORIGIN_LONGITUDE,
CONF_DESTINATION_LATITUDE: CAR_DESTINATION_LATITUDE,
CONF_DESTINATION_LONGITUDE: CAR_DESTINATION_LONGITUDE,
CONF_NAME: "test_name",
CONF_MODE: TRAVEL_MODE_CAR,
CONF_ARRIVAL: "08:00:00",
CONF_ROUTE_MODE: ROUTE_MODE_FASTEST,
CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC,
CONF_TRAFFIC_MODE: TRAFFIC_MODE_ENABLED,
},
)
assert result["type"] == data_entry_flow.FlowResultType.ABORT
assert result["reason"] == "already_configured"

25
tests/components/here_travel_time/test_sensor.py
View File

@ -474,28 +474,3 @@ async def test_route_not_found(hass: HomeAssistant, caplog):
await hass.async_block_till_done()
assert NO_ROUTE_ERROR_MESSAGE in caplog.text
@pytest.mark.usefixtures("valid_response")
async def test_setup_platform(hass: HomeAssistant, caplog):
"""Test that setup platform migration works."""
config = {
"sensor": {
"platform": DOMAIN,
"name": "test",
"origin_latitude": CAR_ORIGIN_LATITUDE,
"origin_longitude": CAR_ORIGIN_LONGITUDE,
"destination_latitude": CAR_DESTINATION_LATITUDE,
"destination_longitude": CAR_DESTINATION_LONGITUDE,
"api_key": API_KEY,
}
}
with patch(
"homeassistant.components.here_travel_time.async_setup_entry", return_value=True
):
await async_setup_component(hass, "sensor", config)
await hass.async_block_till_done()
assert (
"Your HERE travel time configuration has been imported into the UI"
in caplog.text
)