Remove deprecated yaml config from google travel time (#62468)

homeassistant/components/google_travel_time/__init__.py

@@ -1,6 +1,4 @@
 """The google_travel_time component."""
-import logging
-
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
@@ -10,7 +8,6 @@ from homeassistant.helpers.entity_registry import (
 )
 
 PLATFORMS = [Platform.SENSOR]
-_LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

homeassistant/components/google_travel_time/config_flow.py

@@ -2,13 +2,12 @@
 from __future__ import annotations
 
 import logging
-from typing import Any
 
 import voluptuous as vol
 
 from homeassistant import config_entries
 from homeassistant.const import CONF_API_KEY, CONF_MODE, CONF_NAME
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
 from .const import (
@@ -20,14 +19,12 @@ from .const import (
     CONF_DEPARTURE_TIME,
     CONF_DESTINATION,
     CONF_LANGUAGE,
-    CONF_OPTIONS,
     CONF_ORIGIN,
     CONF_TIME,
     CONF_TIME_TYPE,
     CONF_TRAFFIC_MODEL,
     CONF_TRANSIT_MODE,
     CONF_TRANSIT_ROUTING_PREFERENCE,
-    CONF_TRAVEL_MODE,
     CONF_UNITS,
     DEFAULT_NAME,
     DEPARTURE_TIME,
@@ -44,47 +41,6 @@ from .helpers import is_valid_config_entry
 _LOGGER = logging.getLogger(__name__)
 
 
-def is_dupe_import(
-    hass: HomeAssistant, entry: config_entries.ConfigEntry, user_input: dict[str, Any]
-) -> bool:
-    """Return whether imported config already exists."""
-    # Check the main data keys
-    if any(
-        entry.data[key] != user_input[key]
-        for key in (CONF_API_KEY, CONF_DESTINATION, CONF_ORIGIN)
-    ):
-        return False
-
-    options = user_input.get(CONF_OPTIONS, {})
-
-    # We have to check for units differently because there is a default
-    units = options.get(CONF_UNITS) or hass.config.units.name
-    if entry.options[CONF_UNITS] != units:
-        return False
-
-    # We have to check for travel mode differently because of the default and because
-    # it can be provided in two different ways. We have to give mode preference over
-    # travel mode because that's the way that entry setup works.
-    mode = options.get(CONF_MODE) or user_input.get(CONF_TRAVEL_MODE) or "driving"
-    if entry.options[CONF_MODE] != mode:
-        return False
-
-    # We have to check for options that don't have defaults
-    for key in (
-        CONF_LANGUAGE,
-        CONF_AVOID,
-        CONF_ARRIVAL_TIME,
-        CONF_DEPARTURE_TIME,
-        CONF_TRAFFIC_MODEL,
-        CONF_TRANSIT_MODE,
-        CONF_TRANSIT_ROUTING_PREFERENCE,
-    ):
-        if options.get(key) != entry.options.get(key):
-            return False
-
-    return True
-
-
 class GoogleOptionsFlow(config_entries.OptionsFlow):
     """Handle an options flow for Google Travel Time."""
 
@@ -171,24 +127,13 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         errors = {}
         user_input = user_input or {}
         if user_input:
-            # We need to prevent duplicate imports
+            if await self.hass.async_add_executor_job(
-            if self.source == config_entries.SOURCE_IMPORT and any(
+                is_valid_config_entry,
-                is_dupe_import(self.hass, entry, user_input)
+                self.hass,
-                for entry in self.hass.config_entries.async_entries(DOMAIN)
+                _LOGGER,
-                if entry.source == config_entries.SOURCE_IMPORT
+                user_input[CONF_API_KEY],
-            ):
+                user_input[CONF_ORIGIN],
-                return self.async_abort(reason="already_configured")
+                user_input[CONF_DESTINATION],
-
-            if (
-                self.source == config_entries.SOURCE_IMPORT
-                or await self.hass.async_add_executor_job(
-                    is_valid_config_entry,
-                    self.hass,
-                    _LOGGER,
-                    user_input[CONF_API_KEY],
-                    user_input[CONF_ORIGIN],
-                    user_input[CONF_DESTINATION],
-                )
             ):
                 return self.async_create_entry(
                     title=user_input.get(CONF_NAME, DEFAULT_NAME),
@@ -212,5 +157,3 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
             ),
             errors=errors,
         )
-
-    async_step_import = async_step_user

homeassistant/components/google_travel_time/sensor.py

@@ -6,51 +6,35 @@ import logging
 
 from googlemaps import Client
 from googlemaps.distance_matrix import distance_matrix
-import voluptuous as vol
 
-from homeassistant.components.sensor import PLATFORM_SCHEMA, SensorEntity
+from homeassistant.components.sensor import SensorEntity
-from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     ATTR_ATTRIBUTION,
     CONF_API_KEY,
-    CONF_ENTITY_NAMESPACE,
     CONF_MODE,
     CONF_NAME,
-    CONF_SCAN_INTERVAL,
     EVENT_HOMEASSISTANT_STARTED,
     TIME_MINUTES,
 )
 from homeassistant.core import CoreState, 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
 import homeassistant.util.dt as dt_util
 
 from .const import (
-    ALL_LANGUAGES,
     ATTRIBUTION,
-    AVOID,
     CONF_ARRIVAL_TIME,
-    CONF_AVOID,
     CONF_DEPARTURE_TIME,
     CONF_DESTINATION,
-    CONF_LANGUAGE,
     CONF_OPTIONS,
     CONF_ORIGIN,
-    CONF_TRAFFIC_MODEL,
-    CONF_TRANSIT_MODE,
-    CONF_TRANSIT_ROUTING_PREFERENCE,
     CONF_TRAVEL_MODE,
     CONF_UNITS,
     DEFAULT_NAME,
     DOMAIN,
     TRACKABLE_DOMAINS,
-    TRANSIT_PREFS,
-    TRANSPORT_TYPE,
-    TRAVEL_MODE,
-    TRAVEL_MODEL,
-    UNITS,
 )
 from .helpers import get_location_from_entity, resolve_zone
 
@@ -58,38 +42,6 @@ _LOGGER = logging.getLogger(__name__)
 
 SCAN_INTERVAL = timedelta(minutes=5)
 
-PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
-    {
-        vol.Required(CONF_API_KEY): cv.string,
-        vol.Required(CONF_DESTINATION): cv.string,
-        vol.Required(CONF_ORIGIN): cv.string,
-        vol.Optional(CONF_NAME): cv.string,
-        vol.Optional(CONF_TRAVEL_MODE): vol.In(TRAVEL_MODE),
-        vol.Optional(CONF_OPTIONS, default={CONF_MODE: "driving"}): vol.All(
-            dict,
-            vol.Schema(
-                {
-                    vol.Optional(CONF_MODE, default="driving"): vol.In(TRAVEL_MODE),
-                    vol.Optional(CONF_LANGUAGE): vol.In(ALL_LANGUAGES),
-                    vol.Optional(CONF_AVOID): vol.In(AVOID),
-                    vol.Optional(CONF_UNITS): vol.In(UNITS),
-                    vol.Exclusive(CONF_ARRIVAL_TIME, "time"): cv.string,
-                    vol.Exclusive(CONF_DEPARTURE_TIME, "time"): cv.string,
-                    vol.Optional(CONF_TRAFFIC_MODEL): vol.In(TRAVEL_MODEL),
-                    vol.Optional(CONF_TRANSIT_MODE): vol.In(TRANSPORT_TYPE),
-                    vol.Optional(CONF_TRANSIT_ROUTING_PREFERENCE): vol.In(
-                        TRANSIT_PREFS
-                    ),
-                }
-            ),
-        ),
-        # Remove options to exclude from import
-        vol.Remove(CONF_ENTITY_NAMESPACE): cv.string,
-        vol.Remove(CONF_SCAN_INTERVAL): cv.time_period,
-    },
-    extra=vol.REMOVE_EXTRA,
-)
-
 
 def convert_time_to_utc(timestr):
     """Take a string like 08:00:00 and convert it to a unix timestamp."""
@@ -145,25 +97,6 @@ async def async_setup_entry(
     async_add_entities([sensor], False)
 
 
-async def async_setup_platform(
-    hass: HomeAssistant, config, add_entities_callback, discovery_info=None
-):
-    """Set up the Google travel time platform."""
-    hass.async_create_task(
-        hass.config_entries.flow.async_init(
-            DOMAIN,
-            context={"source": SOURCE_IMPORT},
-            data=config,
-        )
-    )
-
-    _LOGGER.warning(
-        "Your Google 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"
-    )
-
-
 class GoogleTravelTimeSensor(SensorEntity):
     """Representation of a Google travel time sensor."""
 

tests/components/google_travel_time/test_config_flow.py

@@ -7,14 +7,12 @@ from homeassistant.components.google_travel_time.const import (
     CONF_DEPARTURE_TIME,
     CONF_DESTINATION,
     CONF_LANGUAGE,
-    CONF_OPTIONS,
     CONF_ORIGIN,
     CONF_TIME,
     CONF_TIME_TYPE,
     CONF_TRAFFIC_MODEL,
     CONF_TRANSIT_MODE,
     CONF_TRANSIT_ROUTING_PREFERENCE,
-    CONF_TRAVEL_MODE,
     CONF_UNITS,
     DEFAULT_NAME,
     DEPARTURE_TIME,
@@ -25,7 +23,6 @@ from homeassistant.const import (
     CONF_MODE,
     CONF_NAME,
     CONF_UNIT_SYSTEM_IMPERIAL,
-    CONF_UNIT_SYSTEM_METRIC,
 )
 
 from tests.common import MockConfigEntry
@@ -236,379 +233,3 @@ async def test_dupe(hass, validate_config_entry, bypass_setup):
     await hass.async_block_till_done()
 
     assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-
-
-async def test_import_flow(hass, validate_config_entry, bypass_update):
-    """Test import_flow."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_MODE: "driving",
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    await hass.async_block_till_done()
-
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-    assert result["title"] == "test_name"
-    assert result["data"] == {
-        CONF_API_KEY: "api_key",
-        CONF_ORIGIN: "location1",
-        CONF_DESTINATION: "location2",
-        CONF_NAME: "test_name",
-        CONF_OPTIONS: {
-            CONF_MODE: "driving",
-            CONF_LANGUAGE: "en",
-            CONF_AVOID: "tolls",
-            CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-            CONF_ARRIVAL_TIME: "test",
-            CONF_TRAFFIC_MODEL: "best_guess",
-            CONF_TRANSIT_MODE: "train",
-            CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-        },
-    }
-
-    entry = hass.config_entries.async_entries(DOMAIN)[0]
-    assert entry.data == {
-        CONF_NAME: "test_name",
-        CONF_API_KEY: "api_key",
-        CONF_ORIGIN: "location1",
-        CONF_DESTINATION: "location2",
-    }
-    assert entry.options == {
-        CONF_MODE: "driving",
-        CONF_LANGUAGE: "en",
-        CONF_AVOID: "tolls",
-        CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-        CONF_ARRIVAL_TIME: "test",
-        CONF_TRAFFIC_MODEL: "best_guess",
-        CONF_TRANSIT_MODE: "train",
-        CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-    }
-
-
-async def test_dupe_import_no_options(hass, bypass_update):
-    """Test duplicate import with no options."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_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: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
-    assert result["reason"] == "already_configured"
-
-
-async def test_dupe_import_default_options(hass, bypass_update):
-    """Test duplicate import with default options."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_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: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
-    assert result["reason"] == "already_configured"
-
-
-async def _setup_dupe_import(hass, bypass_update):
-    """Set up dupe import."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_MODE: "walking",
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-    await hass.async_block_till_done()
-
-
-async def test_dupe_import(hass, bypass_update):
-    """Test duplicate import."""
-    await _setup_dupe_import(hass, bypass_update)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_MODE: "walking",
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
-    assert result["reason"] == "already_configured"
-
-
-async def test_dupe_import_false_check_data_keys(hass, bypass_update):
-    """Test false duplicate import check when data keys differ."""
-    await _setup_dupe_import(hass, bypass_update)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key2",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_MODE: "walking",
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-
-
-async def test_dupe_import_false_check_no_units(hass, bypass_update):
-    """Test false duplicate import check when units aren't provided."""
-    await _setup_dupe_import(hass, bypass_update)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_MODE: "walking",
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-
-
-async def test_dupe_import_false_check_units(hass, bypass_update):
-    """Test false duplicate import check when units are provided but different."""
-    await _setup_dupe_import(hass, bypass_update)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_MODE: "walking",
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_METRIC,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-
-
-async def test_dupe_import_false_check_travel_mode(hass, bypass_update):
-    """Test false duplicate import check when travel mode differs."""
-    await _setup_dupe_import(hass, bypass_update)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_TRAVEL_MODE: "driving",
-            CONF_OPTIONS: {
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-
-
-async def test_dupe_import_false_check_mode(hass, bypass_update):
-    """Test false duplicate import check when mode diiffers."""
-    await _setup_dupe_import(hass, bypass_update)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_MODE: "driving",
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-
-
-async def test_dupe_import_false_check_no_mode(hass, bypass_update):
-    """Test false duplicate import check when no mode is provided."""
-    await _setup_dupe_import(hass, bypass_update)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_LANGUAGE: "en",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-
-
-async def test_dupe_import_false_check_options(hass, bypass_update):
-    """Test false duplicate import check when options differ."""
-    await _setup_dupe_import(hass, bypass_update)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": config_entries.SOURCE_IMPORT},
-        data={
-            CONF_API_KEY: "api_key",
-            CONF_ORIGIN: "location1",
-            CONF_DESTINATION: "location2",
-            CONF_NAME: "test_name",
-            CONF_OPTIONS: {
-                CONF_MODE: "walking",
-                CONF_AVOID: "tolls",
-                CONF_UNITS: CONF_UNIT_SYSTEM_IMPERIAL,
-                CONF_ARRIVAL_TIME: "test",
-                CONF_TRAFFIC_MODEL: "best_guess",
-                CONF_TRANSIT_MODE: "train",
-                CONF_TRANSIT_ROUTING_PREFERENCE: "less_walking",
-            },
-        },
-    )
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY