Remove deprecated YAML import for here_travel_time (#77959)

homeassistant/components/here_travel_time/config_flow.py

@@ -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."""

homeassistant/components/here_travel_time/sensor.py

@@ -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,

tests/components/here_travel_time/test_config_flow.py

@@ -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"

tests/components/here_travel_time/test_sensor.py

@@ -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
-        )