diff --git a/homeassistant/components/tessie/__init__.py b/homeassistant/components/tessie/__init__.py
index 37fb669e54be90667b0737afed9fd3cf71e94fb3..e8891d6665f81bcb111396b4ce65e069aa64f27a 100644
--- a/homeassistant/components/tessie/__init__.py
+++ b/homeassistant/components/tessie/__init__.py
@@ -1,9 +1,12 @@
 """Tessie integration."""
 
+import asyncio
 from http import HTTPStatus
 import logging
 
 from aiohttp import ClientError, ClientResponseError
+from tesla_fleet_api import EnergySpecific, Tessie
+from tesla_fleet_api.exceptions import TeslaFleetError
 from tessie_api import get_state_of_all_vehicles
 
 from homeassistant.config_entries import ConfigEntry
@@ -14,8 +17,12 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.device_registry import DeviceInfo
 
 from .const import DOMAIN, MODELS
-from .coordinator import TessieStateUpdateCoordinator
-from .models import TessieData, TessieVehicleData
+from .coordinator import (
+    TessieEnergySiteInfoCoordinator,
+    TessieEnergySiteLiveCoordinator,
+    TessieStateUpdateCoordinator,
+)
+from .models import TessieData, TessieEnergyData, TessieVehicleData
 
 PLATFORMS = [
     Platform.BINARY_SENSOR,
@@ -40,10 +47,11 @@ type TessieConfigEntry = ConfigEntry[TessieData]
 async def async_setup_entry(hass: HomeAssistant, entry: TessieConfigEntry) -> bool:
     """Set up Tessie config."""
     api_key = entry.data[CONF_ACCESS_TOKEN]
+    session = async_get_clientsession(hass)
 
     try:
         state_of_all_vehicles = await get_state_of_all_vehicles(
-            session=async_get_clientsession(hass),
+            session=session,
             api_key=api_key,
             only_active=True,
         )
@@ -84,7 +92,45 @@ async def async_setup_entry(hass: HomeAssistant, entry: TessieConfigEntry) -> bo
         if vehicle["last_state"] is not None
     ]
 
-    entry.runtime_data = TessieData(vehicles=vehicles)
+    # Energy Sites
+    tessie = Tessie(session, api_key)
+    try:
+        products = (await tessie.products())["response"]
+    except TeslaFleetError as e:
+        raise ConfigEntryNotReady from e
+
+    energysites: list[TessieEnergyData] = []
+    for product in products:
+        if "energy_site_id" in product:
+            site_id = product["energy_site_id"]
+            api = EnergySpecific(tessie.energy, site_id)
+            energysites.append(
+                TessieEnergyData(
+                    api=api,
+                    id=site_id,
+                    live_coordinator=TessieEnergySiteLiveCoordinator(hass, api),
+                    info_coordinator=TessieEnergySiteInfoCoordinator(hass, api),
+                    device=DeviceInfo(
+                        identifiers={(DOMAIN, str(site_id))},
+                        manufacturer="Tesla",
+                        name=product.get("site_name", "Energy Site"),
+                    ),
+                )
+            )
+
+    # Populate coordinator data before forwarding to platforms
+    await asyncio.gather(
+        *(
+            energysite.live_coordinator.async_config_entry_first_refresh()
+            for energysite in energysites
+        ),
+        *(
+            energysite.info_coordinator.async_config_entry_first_refresh()
+            for energysite in energysites
+        ),
+    )
+
+    entry.runtime_data = TessieData(vehicles, energysites)
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
diff --git a/homeassistant/components/tessie/const.py b/homeassistant/components/tessie/const.py
index f717d758f5a68d32a74ce86d40bb3cb6d67b7a2f..bdb201936139a37390b0654a7cd8ec3df2a0d729 100644
--- a/homeassistant/components/tessie/const.py
+++ b/homeassistant/components/tessie/const.py
@@ -79,3 +79,18 @@ TessieChargeStates = {
     "Disconnected": "disconnected",
     "NoPower": "no_power",
 }
+
+
+class TessieWallConnectorStates(IntEnum):
+    """Tessie Wall Connector states."""
+
+    BOOTING = 0
+    CHARGING = 1
+    DISCONNECTED = 2
+    CONNECTED = 4
+    SCHEDULED = 5
+    NEGOTIATING = 6
+    ERROR = 7
+    CHARGING_FINISHED = 8
+    WAITING_CAR = 9
+    CHARGING_REDUCED = 10
diff --git a/homeassistant/components/tessie/coordinator.py b/homeassistant/components/tessie/coordinator.py
index bea1bf72a8de48c89df7686de7efeb0411ac7e54..4582260bfb24952ff644f230b784e69fc729bccc 100644
--- a/homeassistant/components/tessie/coordinator.py
+++ b/homeassistant/components/tessie/coordinator.py
@@ -6,21 +6,37 @@ import logging
 from typing import Any
 
 from aiohttp import ClientResponseError
+from tesla_fleet_api import EnergySpecific
+from tesla_fleet_api.exceptions import InvalidToken, MissingToken, TeslaFleetError
 from tessie_api import get_state, get_status
 
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import TessieStatus
 
 # This matches the update interval Tessie performs server side
 TESSIE_SYNC_INTERVAL = 10
+TESSIE_FLEET_API_SYNC_INTERVAL = timedelta(seconds=30)
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def flatten(data: dict[str, Any], parent: str | None = None) -> dict[str, Any]:
+    """Flatten the data structure."""
+    result = {}
+    for key, value in data.items():
+        if parent:
+            key = f"{parent}_{key}"
+        if isinstance(value, dict):
+            result.update(flatten(value, key))
+        else:
+            result[key] = value
+    return result
+
+
 class TessieStateUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Class to manage fetching data from the Tessie API."""
 
@@ -41,7 +57,7 @@ class TessieStateUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         self.api_key = api_key
         self.vin = vin
         self.session = async_get_clientsession(hass)
-        self.data = self._flatten(data)
+        self.data = flatten(data)
 
     async def _async_update_data(self) -> dict[str, Any]:
         """Update vehicle data using Tessie API."""
@@ -68,18 +84,61 @@ class TessieStateUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 raise ConfigEntryAuthFailed from e
             raise
 
-        return self._flatten(vehicle)
-
-    def _flatten(
-        self, data: dict[str, Any], parent: str | None = None
-    ) -> dict[str, Any]:
-        """Flatten the data structure."""
-        result = {}
-        for key, value in data.items():
-            if parent:
-                key = f"{parent}_{key}"
-            if isinstance(value, dict):
-                result.update(self._flatten(value, key))
-            else:
-                result[key] = value
-        return result
+        return flatten(vehicle)
+
+
+class TessieEnergySiteLiveCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Class to manage fetching energy site live status from the Tessie API."""
+
+    def __init__(self, hass: HomeAssistant, api: EnergySpecific) -> None:
+        """Initialize Tessie Energy Site Live coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="Tessie Energy Site Live",
+            update_interval=TESSIE_FLEET_API_SYNC_INTERVAL,
+        )
+        self.api = api
+
+    async def _async_update_data(self) -> dict[str, Any]:
+        """Update energy site data using Tessie API."""
+
+        try:
+            data = (await self.api.live_status())["response"]
+        except (InvalidToken, MissingToken) as e:
+            raise ConfigEntryAuthFailed from e
+        except TeslaFleetError as e:
+            raise UpdateFailed(e.message) from e
+
+        # Convert Wall Connectors from array to dict
+        data["wall_connectors"] = {
+            wc["din"]: wc for wc in (data.get("wall_connectors") or [])
+        }
+
+        return data
+
+
+class TessieEnergySiteInfoCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Class to manage fetching energy site info from the Tessie API."""
+
+    def __init__(self, hass: HomeAssistant, api: EnergySpecific) -> None:
+        """Initialize Tessie Energy Info coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="Tessie Energy Site Info",
+            update_interval=TESSIE_FLEET_API_SYNC_INTERVAL,
+        )
+        self.api = api
+
+    async def _async_update_data(self) -> dict[str, Any]:
+        """Update energy site data using Tessie API."""
+
+        try:
+            data = (await self.api.site_info())["response"]
+        except (InvalidToken, MissingToken) as e:
+            raise ConfigEntryAuthFailed from e
+        except TeslaFleetError as e:
+            raise UpdateFailed(e.message) from e
+
+        return flatten(data)
diff --git a/homeassistant/components/tessie/entity.py b/homeassistant/components/tessie/entity.py
index 1b7ddcbe84c35b7079d881a37c9702e7c39b1ba8..93b9f10ae67ca455018d7526c818cc13ad7981fe 100644
--- a/homeassistant/components/tessie/entity.py
+++ b/homeassistant/components/tessie/entity.py
@@ -1,36 +1,47 @@
 """Tessie parent entity class."""
 
+from abc import abstractmethod
 from collections.abc import Awaitable, Callable
 from typing import Any
 
 from aiohttp import ClientResponseError
 
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
-from .coordinator import TessieStateUpdateCoordinator
-from .models import TessieVehicleData
+from .coordinator import (
+    TessieEnergySiteInfoCoordinator,
+    TessieEnergySiteLiveCoordinator,
+    TessieStateUpdateCoordinator,
+)
+from .models import TessieEnergyData, TessieVehicleData
 
 
-class TessieEntity(CoordinatorEntity[TessieStateUpdateCoordinator]):
-    """Parent class for Tessie Entities."""
+class TessieBaseEntity(
+    CoordinatorEntity[
+        TessieStateUpdateCoordinator
+        | TessieEnergySiteInfoCoordinator
+        | TessieEnergySiteLiveCoordinator
+    ]
+):
+    """Parent class for Tessie entities."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        vehicle: TessieVehicleData,
+        coordinator: TessieStateUpdateCoordinator
+        | TessieEnergySiteInfoCoordinator
+        | TessieEnergySiteLiveCoordinator,
         key: str,
     ) -> None:
         """Initialize common aspects of a Tessie entity."""
-        super().__init__(vehicle.data_coordinator)
-        self.vin = vehicle.vin
-        self.key = key
 
+        self.key = key
         self._attr_translation_key = key
-        self._attr_unique_id = f"{vehicle.vin}-{key}"
-        self._attr_device_info = vehicle.device
+        super().__init__(coordinator)
 
     @property
     def _value(self) -> Any:
@@ -41,15 +52,53 @@ class TessieEntity(CoordinatorEntity[TessieStateUpdateCoordinator]):
         """Return a specific value from coordinator data."""
         return self.coordinator.data.get(key or self.key, default)
 
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._async_update_attrs()
+        super()._handle_coordinator_update()
+
+    @abstractmethod
+    def _async_update_attrs(self) -> None:
+        """Update the attributes of the entity."""
+
+
+class TessieEntity(TessieBaseEntity):
+    """Parent class for Tessie vehicle entities."""
+
+    def __init__(
+        self,
+        vehicle: TessieVehicleData,
+        key: str,
+    ) -> None:
+        """Initialize common aspects of a Tessie vehicle entity."""
+        self.vin = vehicle.vin
+        self._session = vehicle.data_coordinator.session
+        self._api_key = vehicle.data_coordinator.api_key
+        self._attr_unique_id = f"{vehicle.vin}-{key}"
+        self._attr_device_info = vehicle.device
+
+        super().__init__(vehicle.data_coordinator, key)
+
+    @property
+    def _value(self) -> Any:
+        """Return value from coordinator data."""
+        return self.coordinator.data.get(self.key)
+
+    def set(self, *args: Any) -> None:
+        """Set a value in coordinator data."""
+        for key, value in args:
+            self.coordinator.data[key] = value
+        self.async_write_ha_state()
+
     async def run(
         self, func: Callable[..., Awaitable[dict[str, Any]]], **kargs: Any
     ) -> None:
         """Run a tessie_api function and handle exceptions."""
         try:
             response = await func(
-                session=self.coordinator.session,
+                session=self._session,
                 vin=self.vin,
-                api_key=self.coordinator.api_key,
+                api_key=self._api_key,
                 **kargs,
             )
         except ClientResponseError as e:
@@ -63,8 +112,55 @@ class TessieEntity(CoordinatorEntity[TessieStateUpdateCoordinator]):
                 translation_placeholders={"name": name},
             )
 
-    def set(self, *args: Any) -> None:
-        """Set a value in coordinator data."""
-        for key, value in args:
-            self.coordinator.data[key] = value
-        self.async_write_ha_state()
+    def _async_update_attrs(self) -> None:
+        """Update the attributes of the entity."""
+        # Not used in this class yet
+
+
+class TessieEnergyEntity(TessieBaseEntity):
+    """Parent class for Tessie energy site entities."""
+
+    def __init__(
+        self,
+        data: TessieEnergyData,
+        coordinator: TessieEnergySiteInfoCoordinator | TessieEnergySiteLiveCoordinator,
+        key: str,
+    ) -> None:
+        """Initialize common aspects of a Tessie energy site entity."""
+
+        self._attr_unique_id = f"{data.id}-{key}"
+        self._attr_device_info = data.device
+
+        super().__init__(coordinator, key)
+
+
+class TessieWallConnectorEntity(TessieBaseEntity):
+    """Parent class for Tessie wall connector entities."""
+
+    def __init__(
+        self,
+        data: TessieEnergyData,
+        din: str,
+        key: str,
+    ) -> None:
+        """Initialize common aspects of a Teslemetry entity."""
+        self.din = din
+        self._attr_unique_id = f"{data.id}-{din}-{key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, din)},
+            manufacturer="Tesla",
+            name="Wall Connector",
+            via_device=(DOMAIN, str(data.id)),
+            serial_number=din.split("-")[-1],
+        )
+
+        super().__init__(data.live_coordinator, key)
+
+    @property
+    def _value(self) -> int:
+        """Return a specific wall connector value from coordinator data."""
+        return (
+            self.coordinator.data.get("wall_connectors", {})
+            .get(self.din, {})
+            .get(self.key)
+        )
diff --git a/homeassistant/components/tessie/icons.json b/homeassistant/components/tessie/icons.json
index 0b1051e662f8bdaf0f251ef463796c1764d3edf3..2543b3ab9e1f66d530ae0cb85c6a6eedbc1e9079 100644
--- a/homeassistant/components/tessie/icons.json
+++ b/homeassistant/components/tessie/icons.json
@@ -189,6 +189,42 @@
       },
       "drive_state_active_route_destination": {
         "default": "mdi:map-marker"
+      },
+      "battery_power": {
+        "default": "mdi:home-battery"
+      },
+      "energy_left": {
+        "default": "mdi:battery"
+      },
+      "generator_power": {
+        "default": "mdi:generator-stationary"
+      },
+      "grid_power": {
+        "default": "mdi:transmission-tower"
+      },
+      "grid_services_power": {
+        "default": "mdi:transmission-tower"
+      },
+      "load_power": {
+        "default": "mdi:power-plug"
+      },
+      "solar_power": {
+        "default": "mdi:solar-power"
+      },
+      "total_pack_energy": {
+        "default": "mdi:battery-high"
+      },
+      "vin": {
+        "default": "mdi:car-electric"
+      },
+      "wall_connector_fault_state": {
+        "default": "mdi:ev-station"
+      },
+      "wall_connector_power": {
+        "default": "mdi:ev-station"
+      },
+      "wall_connector_state": {
+        "default": "mdi:ev-station"
       }
     },
     "switch": {
diff --git a/homeassistant/components/tessie/manifest.json b/homeassistant/components/tessie/manifest.json
index 52fc8dd5be11d5ea6284f543d87c2c8c37cf220c..bf1ab5f61e4eb4f0662a0d48ade3c308fa4c23fd 100644
--- a/homeassistant/components/tessie/manifest.json
+++ b/homeassistant/components/tessie/manifest.json
@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/tessie",
   "iot_class": "cloud_polling",
   "loggers": ["tessie"],
-  "requirements": ["tessie-api==0.0.9"]
+  "requirements": ["tessie-api==0.0.9", "tesla-fleet-api==0.6.1"]
 }
diff --git a/homeassistant/components/tessie/models.py b/homeassistant/components/tessie/models.py
index e96562ff8e1b58281c629a4997280c4ecbec6e55..ca670b9650b805e3f08c9de2ce8a6d80388a728e 100644
--- a/homeassistant/components/tessie/models.py
+++ b/homeassistant/components/tessie/models.py
@@ -4,9 +4,15 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from tesla_fleet_api import EnergySpecific
+
 from homeassistant.helpers.device_registry import DeviceInfo
 
-from .coordinator import TessieStateUpdateCoordinator
+from .coordinator import (
+    TessieEnergySiteInfoCoordinator,
+    TessieEnergySiteLiveCoordinator,
+    TessieStateUpdateCoordinator,
+)
 
 
 @dataclass
@@ -14,6 +20,18 @@ class TessieData:
     """Data for the Tessie integration."""
 
     vehicles: list[TessieVehicleData]
+    energysites: list[TessieEnergyData]
+
+
+@dataclass
+class TessieEnergyData:
+    """Data for a Energy Site in the Tessie integration."""
+
+    api: EnergySpecific
+    live_coordinator: TessieEnergySiteLiveCoordinator
+    info_coordinator: TessieEnergySiteInfoCoordinator
+    id: int
+    device: DeviceInfo
 
 
 @dataclass
diff --git a/homeassistant/components/tessie/sensor.py b/homeassistant/components/tessie/sensor.py
index dc910c7a03abb8b79a69a4ec1c111685cedaada8..586162fe779a9f7160b87750bd9b2f0cec44e310 100644
--- a/homeassistant/components/tessie/sensor.py
+++ b/homeassistant/components/tessie/sensor.py
@@ -5,6 +5,7 @@ from __future__ import annotations
 from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime, timedelta
+from itertools import chain
 from typing import cast
 
 from homeassistant.components.sensor import (
@@ -33,9 +34,9 @@ from homeassistant.util import dt as dt_util
 from homeassistant.util.variance import ignore_variance
 
 from . import TessieConfigEntry
-from .const import TessieChargeStates
-from .entity import TessieEntity
-from .models import TessieVehicleData
+from .const import TessieChargeStates, TessieWallConnectorStates
+from .entity import TessieEnergyEntity, TessieEntity, TessieWallConnectorEntity
+from .models import TessieEnergyData, TessieVehicleData
 
 
 @callback
@@ -257,6 +258,115 @@ DESCRIPTIONS: tuple[TessieSensorEntityDescription, ...] = (
     ),
 )
 
+ENERGY_LIVE_DESCRIPTIONS: tuple[TessieSensorEntityDescription, ...] = (
+    TessieSensorEntityDescription(
+        key="solar_power",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.POWER,
+    ),
+    TessieSensorEntityDescription(
+        key="energy_left",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.ENERGY_STORAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    TessieSensorEntityDescription(
+        key="total_pack_energy",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.ENERGY_STORAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    TessieSensorEntityDescription(
+        key="percentage_charged",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PERCENTAGE,
+        device_class=SensorDeviceClass.BATTERY,
+        suggested_display_precision=2,
+    ),
+    TessieSensorEntityDescription(
+        key="battery_power",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.POWER,
+    ),
+    TessieSensorEntityDescription(
+        key="load_power",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.POWER,
+    ),
+    TessieSensorEntityDescription(
+        key="grid_power",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.POWER,
+    ),
+    TessieSensorEntityDescription(
+        key="grid_services_power",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.POWER,
+    ),
+    TessieSensorEntityDescription(
+        key="generator_power",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.POWER,
+        entity_registry_enabled_default=False,
+    ),
+)
+
+WALL_CONNECTOR_DESCRIPTIONS: tuple[TessieSensorEntityDescription, ...] = (
+    TessieSensorEntityDescription(
+        key="wall_connector_state",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        device_class=SensorDeviceClass.ENUM,
+        value_fn=lambda x: TessieWallConnectorStates(cast(int, x)).name.lower(),
+        options=[state.name.lower() for state in TessieWallConnectorStates],
+    ),
+    TessieSensorEntityDescription(
+        key="wall_connector_power",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+        suggested_display_precision=2,
+        device_class=SensorDeviceClass.POWER,
+    ),
+    TessieSensorEntityDescription(
+        key="vin",
+    ),
+)
+
+ENERGY_INFO_DESCRIPTIONS: tuple[TessieSensorEntityDescription, ...] = (
+    TessieSensorEntityDescription(
+        key="vpp_backup_reserve_percent",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        device_class=SensorDeviceClass.BATTERY,
+        native_unit_of_measurement=PERCENTAGE,
+    ),
+)
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -264,17 +374,38 @@ async def async_setup_entry(
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the Tessie sensor platform from a config entry."""
-    data = entry.runtime_data
 
     async_add_entities(
-        TessieSensorEntity(vehicle, description)
-        for vehicle in data.vehicles
-        for description in DESCRIPTIONS
+        chain(
+            (  # Add vehicles
+                TessieVehicleSensorEntity(vehicle, description)
+                for vehicle in entry.runtime_data.vehicles
+                for description in DESCRIPTIONS
+            ),
+            (  # Add energy site info
+                TessieEnergyInfoSensorEntity(energysite, description)
+                for energysite in entry.runtime_data.energysites
+                for description in ENERGY_INFO_DESCRIPTIONS
+                if description.key in energysite.info_coordinator.data
+            ),
+            (  # Add energy site live
+                TessieEnergyLiveSensorEntity(energysite, description)
+                for energysite in entry.runtime_data.energysites
+                for description in ENERGY_LIVE_DESCRIPTIONS
+                if description.key in energysite.live_coordinator.data
+            ),
+            (  # Add wall connectors
+                TessieWallConnectorSensorEntity(energysite, din, description)
+                for energysite in entry.runtime_data.energysites
+                for din in energysite.live_coordinator.data.get("wall_connectors", {})
+                for description in WALL_CONNECTOR_DESCRIPTIONS
+            ),
+        )
     )
 
 
-class TessieSensorEntity(TessieEntity, SensorEntity):
-    """Base class for Tessie metric sensors."""
+class TessieVehicleSensorEntity(TessieEntity, SensorEntity):
+    """Base class for Tessie sensor entities."""
 
     entity_description: TessieSensorEntityDescription
 
@@ -284,8 +415,8 @@ class TessieSensorEntity(TessieEntity, SensorEntity):
         description: TessieSensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
-        super().__init__(vehicle, description.key)
         self.entity_description = description
+        super().__init__(vehicle, description.key)
 
     @property
     def native_value(self) -> StateType | datetime:
@@ -296,3 +427,68 @@ class TessieSensorEntity(TessieEntity, SensorEntity):
     def available(self) -> bool:
         """Return if sensor is available."""
         return super().available and self.entity_description.available_fn(self.get())
+
+
+class TessieEnergyLiveSensorEntity(TessieEnergyEntity, SensorEntity):
+    """Base class for Tessie energy site sensor entity."""
+
+    entity_description: TessieSensorEntityDescription
+
+    def __init__(
+        self,
+        data: TessieEnergyData,
+        description: TessieSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        self.entity_description = description
+        super().__init__(data, data.live_coordinator, description.key)
+
+    def _async_update_attrs(self) -> None:
+        """Update the attributes of the sensor."""
+        self._attr_available = self._value is not None
+        self._attr_native_value = self.entity_description.value_fn(self._value)
+
+
+class TessieEnergyInfoSensorEntity(TessieEnergyEntity, SensorEntity):
+    """Base class for Tessie energy site sensor entity."""
+
+    entity_description: TessieSensorEntityDescription
+
+    def __init__(
+        self,
+        data: TessieEnergyData,
+        description: TessieSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        self.entity_description = description
+        super().__init__(data, data.info_coordinator, description.key)
+
+    def _async_update_attrs(self) -> None:
+        """Update the attributes of the sensor."""
+        self._attr_available = self._value is not None
+        self._attr_native_value = self._value
+
+
+class TessieWallConnectorSensorEntity(TessieWallConnectorEntity, SensorEntity):
+    """Base class for Tessie wall connector sensor entity."""
+
+    entity_description: TessieSensorEntityDescription
+
+    def __init__(
+        self,
+        data: TessieEnergyData,
+        din: str,
+        description: TessieSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        self.entity_description = description
+        super().__init__(
+            data,
+            din,
+            description.key,
+        )
+
+    def _async_update_attrs(self) -> None:
+        """Update the attributes of the sensor."""
+        self._attr_available = self._value is not None
+        self._attr_native_value = self.entity_description.value_fn(self._value)
diff --git a/homeassistant/components/tessie/strings.json b/homeassistant/components/tessie/strings.json
index ea75660ddb7d60024d62e2564bc9dab0ae5b0f04..8e617f137dca12d5977240cde0975c91f5c95aae 100644
--- a/homeassistant/components/tessie/strings.json
+++ b/homeassistant/components/tessie/strings.json
@@ -167,6 +167,60 @@
       },
       "drive_state_active_route_destination": {
         "name": "Destination"
+      },
+      "battery_power": {
+        "name": "Battery power"
+      },
+      "energy_left": {
+        "name": "Energy left"
+      },
+      "generator_power": {
+        "name": "Generator power"
+      },
+      "grid_power": {
+        "name": "Grid power"
+      },
+      "grid_services_power": {
+        "name": "Grid services power"
+      },
+      "load_power": {
+        "name": "Load power"
+      },
+      "percentage_charged": {
+        "name": "Percentage charged"
+      },
+      "solar_power": {
+        "name": "Solar power"
+      },
+      "total_pack_energy": {
+        "name": "Total pack energy"
+      },
+      "vin": {
+        "name": "Vehicle"
+      },
+      "vpp_backup_reserve_percent": {
+        "name": "VPP backup reserve"
+      },
+      "wall_connector_fault_state": {
+        "name": "Fault state code"
+      },
+      "wall_connector_power": {
+        "name": "Power"
+      },
+      "wall_connector_state": {
+        "name": "State",
+        "state": {
+          "booting": "Booting",
+          "charging": "[%key:component::tessie::entity::sensor::charge_state_charging_state::state::charging%]",
+          "disconnected": "[%key:common::state::disconnected%]",
+          "connected": "[%key:common::state::connected%]",
+          "scheduled": "Scheduled",
+          "negotiating": "Negotiating",
+          "error": "Error",
+          "charging_finished": "Charging finished",
+          "waiting_car": "Waiting car",
+          "charging_reduced": "Charging reduced"
+        }
       }
     },
     "cover": {
diff --git a/requirements_all.txt b/requirements_all.txt
index 2ec7f38e5e3cb30ad19cbea3d9bf1e4f89d283fb..f4de7dafa87240e302939de89a298aab6b8f0cfb 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -2713,6 +2713,7 @@ temperusb==1.6.1
 # tensorflow==2.5.0
 
 # homeassistant.components.teslemetry
+# homeassistant.components.tessie
 tesla-fleet-api==0.6.1
 
 # homeassistant.components.powerwall
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index f0e856c2f6f681f548cd2854b87aa4be1ea2c62b..12ab15a7d768c10ac3e42627efe6240ee401b068 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -2111,6 +2111,7 @@ temescal==0.5
 temperusb==1.6.1
 
 # homeassistant.components.teslemetry
+# homeassistant.components.tessie
 tesla-fleet-api==0.6.1
 
 # homeassistant.components.powerwall
diff --git a/tests/components/tessie/common.py b/tests/components/tessie/common.py
index c19f6f65201bae4d367be00935758773150c6db2..3d24c6b233a784cbcc940c9a12a78704b7eca9bf 100644
--- a/tests/components/tessie/common.py
+++ b/tests/components/tessie/common.py
@@ -16,6 +16,7 @@ from homeassistant.helpers.typing import UNDEFINED, UndefinedType
 
 from tests.common import MockConfigEntry, load_json_object_fixture
 
+# Tessie library
 TEST_STATE_OF_ALL_VEHICLES = load_json_object_fixture("vehicles.json", DOMAIN)
 TEST_VEHICLE_STATE_ONLINE = load_json_object_fixture("online.json", DOMAIN)
 TEST_VEHICLE_STATUS_AWAKE = {"status": TessieStatus.AWAKE}
@@ -47,6 +48,13 @@ ERROR_VIRTUAL_KEY = ClientResponseError(
 )
 ERROR_CONNECTION = ClientConnectionError()
 
+# Fleet API library
+PRODUCTS = load_json_object_fixture("products.json", DOMAIN)
+LIVE_STATUS = load_json_object_fixture("live_status.json", DOMAIN)
+SITE_INFO = load_json_object_fixture("site_info.json", DOMAIN)
+RESPONSE_OK = {"response": {}, "error": None}
+COMMAND_OK = {"response": {"result": True, "reason": ""}}
+
 
 async def setup_platform(
     hass: HomeAssistant, platforms: list[Platform] | UndefinedType = UNDEFINED
diff --git a/tests/components/tessie/conftest.py b/tests/components/tessie/conftest.py
index 77d1e3fd3e2898545f37c2b7ba95bbc9ee5aad25..79cc9aa44c60e5560f3d9284991d1884b9ac9983 100644
--- a/tests/components/tessie/conftest.py
+++ b/tests/components/tessie/conftest.py
@@ -2,16 +2,23 @@
 
 from __future__ import annotations
 
+from copy import deepcopy
 from unittest.mock import patch
 
 import pytest
 
 from .common import (
+    COMMAND_OK,
+    LIVE_STATUS,
+    PRODUCTS,
+    SITE_INFO,
     TEST_STATE_OF_ALL_VEHICLES,
     TEST_VEHICLE_STATE_ONLINE,
     TEST_VEHICLE_STATUS_AWAKE,
 )
 
+# Tessie
+
 
 @pytest.fixture(autouse=True)
 def mock_get_state():
@@ -41,3 +48,43 @@ def mock_get_state_of_all_vehicles():
         return_value=TEST_STATE_OF_ALL_VEHICLES,
     ) as mock_get_state_of_all_vehicles:
         yield mock_get_state_of_all_vehicles
+
+
+# Fleet API
+@pytest.fixture(autouse=True)
+def mock_products():
+    """Mock Tesla Fleet Api products method."""
+    with patch(
+        "homeassistant.components.tessie.Tessie.products", return_value=PRODUCTS
+    ) as mock_products:
+        yield mock_products
+
+
+@pytest.fixture(autouse=True)
+def mock_request():
+    """Mock Tesla Fleet API request method."""
+    with patch(
+        "homeassistant.components.tessie.Tessie._request",
+        return_value=COMMAND_OK,
+    ) as mock_request:
+        yield mock_request
+
+
+@pytest.fixture(autouse=True)
+def mock_live_status():
+    """Mock Tesla Fleet API EnergySpecific live_status method."""
+    with patch(
+        "homeassistant.components.tessie.EnergySpecific.live_status",
+        side_effect=lambda: deepcopy(LIVE_STATUS),
+    ) as mock_live_status:
+        yield mock_live_status
+
+
+@pytest.fixture(autouse=True)
+def mock_site_info():
+    """Mock Tesla Fleet API EnergySpecific site_info method."""
+    with patch(
+        "homeassistant.components.tessie.EnergySpecific.site_info",
+        side_effect=lambda: deepcopy(SITE_INFO),
+    ) as mock_live_status:
+        yield mock_live_status
diff --git a/tests/components/tessie/fixtures/live_status.json b/tests/components/tessie/fixtures/live_status.json
new file mode 100644
index 0000000000000000000000000000000000000000..486f9f4fadde367d458bde44b322cd571c982e22
--- /dev/null
+++ b/tests/components/tessie/fixtures/live_status.json
@@ -0,0 +1,33 @@
+{
+  "response": {
+    "solar_power": 1185,
+    "energy_left": 38896.47368421053,
+    "total_pack_energy": 40727,
+    "percentage_charged": 95.50537403739663,
+    "backup_capable": true,
+    "battery_power": 5060,
+    "load_power": 6245,
+    "grid_status": "Active",
+    "grid_services_active": false,
+    "grid_power": 0,
+    "grid_services_power": 0,
+    "generator_power": 0,
+    "island_status": "on_grid",
+    "storm_mode_active": false,
+    "timestamp": "2024-01-01T00:00:00+00:00",
+    "wall_connectors": [
+      {
+        "din": "abd-123",
+        "wall_connector_state": 2,
+        "wall_connector_fault_state": 2,
+        "wall_connector_power": 0
+      },
+      {
+        "din": "bcd-234",
+        "wall_connector_state": 2,
+        "wall_connector_fault_state": 2,
+        "wall_connector_power": 0
+      }
+    ]
+  }
+}
diff --git a/tests/components/tessie/fixtures/products.json b/tests/components/tessie/fixtures/products.json
new file mode 100644
index 0000000000000000000000000000000000000000..e1b76e4cefb5773d7113c14ed23faabae45d3e47
--- /dev/null
+++ b/tests/components/tessie/fixtures/products.json
@@ -0,0 +1,121 @@
+{
+  "response": [
+    {
+      "id": 1234,
+      "user_id": 1234,
+      "vehicle_id": 1234,
+      "vin": "LRWXF7EK4KC700000",
+      "color": null,
+      "access_type": "OWNER",
+      "display_name": "Test",
+      "option_codes": null,
+      "cached_data": null,
+      "granular_access": { "hide_private": false },
+      "tokens": ["abc", "def"],
+      "state": "asleep",
+      "in_service": false,
+      "id_s": "1234",
+      "calendar_enabled": true,
+      "api_version": 71,
+      "backseat_token": null,
+      "backseat_token_updated_at": null,
+      "ble_autopair_enrolled": false,
+      "vehicle_config": {
+        "aux_park_lamps": "Eu",
+        "badge_version": 1,
+        "can_accept_navigation_requests": true,
+        "can_actuate_trunks": true,
+        "car_special_type": "base",
+        "car_type": "model3",
+        "charge_port_type": "CCS",
+        "cop_user_set_temp_supported": false,
+        "dashcam_clip_save_supported": true,
+        "default_charge_to_max": false,
+        "driver_assist": "TeslaAP3",
+        "ece_restrictions": false,
+        "efficiency_package": "M32021",
+        "eu_vehicle": true,
+        "exterior_color": "DeepBlue",
+        "exterior_trim": "Black",
+        "exterior_trim_override": "",
+        "has_air_suspension": false,
+        "has_ludicrous_mode": false,
+        "has_seat_cooling": false,
+        "headlamp_type": "Global",
+        "interior_trim_type": "White2",
+        "key_version": 2,
+        "motorized_charge_port": true,
+        "paint_color_override": "0,9,25,0.7,0.04",
+        "performance_package": "Base",
+        "plg": true,
+        "pws": true,
+        "rear_drive_unit": "PM216MOSFET",
+        "rear_seat_heaters": 1,
+        "rear_seat_type": 0,
+        "rhd": true,
+        "roof_color": "RoofColorGlass",
+        "seat_type": null,
+        "spoiler_type": "None",
+        "sun_roof_installed": null,
+        "supports_qr_pairing": false,
+        "third_row_seats": "None",
+        "timestamp": 1705701487912,
+        "trim_badging": "74d",
+        "use_range_badging": true,
+        "utc_offset": 36000,
+        "webcam_selfie_supported": true,
+        "webcam_supported": true,
+        "wheel_type": "Pinwheel18CapKit"
+      },
+      "command_signing": "allowed",
+      "release_notes_supported": true
+    },
+    {
+      "energy_site_id": 123456,
+      "resource_type": "battery",
+      "site_name": "Energy Site",
+      "id": "ABC123",
+      "gateway_id": "ABC123",
+      "asset_site_id": "c0ffee",
+      "warp_site_number": "GA123456",
+      "energy_left": 23286.105263157893,
+      "total_pack_energy": 40804,
+      "percentage_charged": 57.068192488868476,
+      "battery_type": "ac_powerwall",
+      "backup_capable": true,
+      "battery_power": 14990,
+      "go_off_grid_test_banner_enabled": null,
+      "storm_mode_enabled": true,
+      "powerwall_onboarding_settings_set": true,
+      "powerwall_tesla_electric_interested_in": null,
+      "vpp_tour_enabled": null,
+      "sync_grid_alert_enabled": true,
+      "breaker_alert_enabled": true,
+      "components": {
+        "battery": true,
+        "battery_type": "ac_powerwall",
+        "solar": true,
+        "solar_type": "pv_panel",
+        "grid": true,
+        "load_meter": true,
+        "market_type": "residential",
+        "wall_connectors": [
+          {
+            "device_id": "abc-123",
+            "din": "123-abc",
+            "is_active": true
+          },
+          {
+            "device_id": "bcd-234",
+            "din": "234-bcd",
+            "is_active": true
+          }
+        ]
+      },
+      "features": {
+        "rate_plan_manager_no_pricing_constraint": true
+      }
+    }
+  ],
+  "count": 2
+}
diff --git a/tests/components/tessie/fixtures/site_info.json b/tests/components/tessie/fixtures/site_info.json
new file mode 100644
index 0000000000000000000000000000000000000000..f581707ff14fb873a9aab5a75e4c9ab116ef0fc0
--- /dev/null
+++ b/tests/components/tessie/fixtures/site_info.json
@@ -0,0 +1,125 @@
+{
+  "response": {
+    "id": "1233-abcd",
+    "site_name": "Site",
+    "backup_reserve_percent": 0,
+    "default_real_mode": "self_consumption",
+    "installation_date": "2022-01-01T00:00:00+00:00",
+    "user_settings": {
+      "go_off_grid_test_banner_enabled": false,
+      "storm_mode_enabled": true,
+      "powerwall_onboarding_settings_set": true,
+      "powerwall_tesla_electric_interested_in": false,
+      "vpp_tour_enabled": true,
+      "sync_grid_alert_enabled": true,
+      "breaker_alert_enabled": false
+    },
+    "components": {
+      "solar": true,
+      "solar_type": "pv_panel",
+      "battery": true,
+      "grid": true,
+      "backup": true,
+      "gateway": "teg",
+      "load_meter": true,
+      "tou_capable": true,
+      "storm_mode_capable": true,
+      "flex_energy_request_capable": false,
+      "car_charging_data_supported": false,
+      "off_grid_vehicle_charging_reserve_supported": true,
+      "vehicle_charging_performance_view_enabled": false,
+      "vehicle_charging_solar_offset_view_enabled": false,
+      "battery_solar_offset_view_enabled": true,
+      "solar_value_enabled": true,
+      "energy_value_header": "Energy Value",
+      "energy_value_subheader": "Estimated Value",
+      "energy_service_self_scheduling_enabled": true,
+      "show_grid_import_battery_source_cards": true,
+      "set_islanding_mode_enabled": true,
+      "wifi_commissioning_enabled": true,
+      "backup_time_remaining_enabled": true,
+      "battery_type": "ac_powerwall",
+      "configurable": true,
+      "grid_services_enabled": false,
+      "gateways": [
+        {
+          "device_id": "gateway-id",
+          "din": "gateway-din",
+          "serial_number": "CN00000000J50D",
+          "part_number": "1152100-14-J",
+          "part_type": 10,
+          "part_name": "Tesla Backup Gateway 2",
+          "is_active": true,
+          "site_id": "1234-abcd",
+          "firmware_version": "24.4.0 0fe780c9",
+          "updated_datetime": "2024-05-14T00:00:00.000Z"
+        }
+      ],
+      "batteries": [
+        {
+          "device_id": "battery-1-id",
+          "din": "battery-1-din",
+          "serial_number": "TG000000001DA5",
+          "part_number": "3012170-10-B",
+          "part_type": 2,
+          "part_name": "Powerwall 2",
+          "nameplate_max_charge_power": 5000,
+          "nameplate_max_discharge_power": 5000,
+          "nameplate_energy": 13500
+        },
+        {
+          "device_id": "battery-2-id",
+          "din": "battery-2-din",
+          "serial_number": "TG000000002DA5",
+          "part_number": "3012170-05-C",
+          "part_type": 2,
+          "part_name": "Powerwall 2",
+          "nameplate_max_charge_power": 5000,
+          "nameplate_max_discharge_power": 5000,
+          "nameplate_energy": 13500
+        }
+      ],
+      "wall_connectors": [
+        {
+          "device_id": "123abc",
+          "din": "abc123",
+          "is_active": true
+        },
+        {
+          "device_id": "234bcd",
+          "din": "bcd234",
+          "is_active": true
+        }
+      ],
+      "disallow_charge_from_grid_with_solar_installed": true,
+      "customer_preferred_export_rule": "pv_only",
+      "net_meter_mode": "battery_ok",
+      "system_alerts_enabled": true
+    },
+    "version": "23.44.0 eb113390",
+    "battery_count": 2,
+    "tou_settings": {
+      "optimization_strategy": "economics",
+      "schedule": [
+        {
+          "target": "off_peak",
+          "week_days": [1, 0],
+          "start_seconds": 0,
+          "end_seconds": 3600
+        },
+        {
+          "target": "peak",
+          "week_days": [1, 0],
+          "start_seconds": 3600,
+          "end_seconds": 0
+        }
+      ]
+    },
+    "nameplate_power": 15000,
+    "nameplate_energy": 40500,
+    "installation_time_zone": "",
+    "max_site_meter_power_ac": 1000000000,
+    "min_site_meter_power_ac": -1000000000,
+    "vpp_backup_reserve_percent": 0
+  }
+}
diff --git a/tests/components/tessie/snapshots/test_sensor.ambr b/tests/components/tessie/snapshots/test_sensor.ambr
index 48beab6133cd954d17fda7161fdef2727a63537a..ba7b4eae0a51cbd8f2b7908639dc5528c8cbd40c 100644
--- a/tests/components/tessie/snapshots/test_sensor.ambr
+++ b/tests/components/tessie/snapshots/test_sensor.ambr
@@ -1,5 +1,5 @@
 # serializer version: 1
-# name: test_sensors[sensor.test_battery_level-entry]
+# name: test_sensors[sensor.energy_site_battery_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -13,7 +13,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_battery_level',
+    'entity_id': 'sensor.energy_site_battery_power',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -22,35 +22,41 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 2,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
+      }),
     }),
-    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Battery level',
+    'original_name': 'Battery power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_usable_battery_level',
-    'unique_id': 'VINVINVIN-charge_state_usable_battery_level',
-    'unit_of_measurement': '%',
+    'translation_key': 'battery_power',
+    'unique_id': '123456-battery_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_battery_level-state]
+# name: test_sensors[sensor.energy_site_battery_power-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'battery',
-      'friendly_name': 'Test Battery level',
+      'device_class': 'power',
+      'friendly_name': 'Energy Site Battery power',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': '%',
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_battery_level',
+    'entity_id': 'sensor.energy_site_battery_power',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '75',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_battery_range-entry]
+# name: test_sensors[sensor.energy_site_energy_left-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -63,8 +69,8 @@
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.test_battery_range',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.energy_site_energy_left',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -74,40 +80,40 @@
     'name': None,
     'options': dict({
       'sensor': dict({
-        'suggested_display_precision': 1,
+        'suggested_display_precision': 2,
       }),
       'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+        'suggested_unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
+    'original_device_class': <SensorDeviceClass.ENERGY_STORAGE: 'energy_storage'>,
     'original_icon': None,
-    'original_name': 'Battery range',
+    'original_name': 'Energy left',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_battery_range',
-    'unique_id': 'VINVINVIN-charge_state_battery_range',
-    'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+    'translation_key': 'energy_left',
+    'unique_id': '123456-energy_left',
+    'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
   })
 # ---
-# name: test_sensors[sensor.test_battery_range-state]
+# name: test_sensors[sensor.energy_site_energy_left-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'distance',
-      'friendly_name': 'Test Battery range',
+      'device_class': 'energy_storage',
+      'friendly_name': 'Energy Site Energy left',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+      'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_battery_range',
+    'entity_id': 'sensor.energy_site_energy_left',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '424.35182592',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_battery_range_estimate-entry]
+# name: test_sensors[sensor.energy_site_generator_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -121,7 +127,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_battery_range_estimate',
+    'entity_id': 'sensor.energy_site_generator_power',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -131,40 +137,40 @@
     'name': None,
     'options': dict({
       'sensor': dict({
-        'suggested_display_precision': 1,
+        'suggested_display_precision': 2,
       }),
       'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+        'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Battery range estimate',
+    'original_name': 'Generator power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_est_battery_range',
-    'unique_id': 'VINVINVIN-charge_state_est_battery_range',
-    'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+    'translation_key': 'generator_power',
+    'unique_id': '123456-generator_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_battery_range_estimate-state]
+# name: test_sensors[sensor.energy_site_generator_power-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'distance',
-      'friendly_name': 'Test Battery range estimate',
+      'device_class': 'power',
+      'friendly_name': 'Energy Site Generator power',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_battery_range_estimate',
+    'entity_id': 'sensor.energy_site_generator_power',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '522.60227712',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_battery_range_ideal-entry]
+# name: test_sensors[sensor.energy_site_grid_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -178,7 +184,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_battery_range_ideal',
+    'entity_id': 'sensor.energy_site_grid_power',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -188,46 +194,46 @@
     'name': None,
     'options': dict({
       'sensor': dict({
-        'suggested_display_precision': 1,
+        'suggested_display_precision': 2,
       }),
       'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+        'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Battery range ideal',
+    'original_name': 'Grid power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_ideal_battery_range',
-    'unique_id': 'VINVINVIN-charge_state_ideal_battery_range',
-    'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+    'translation_key': 'grid_power',
+    'unique_id': '123456-grid_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_battery_range_ideal-state]
+# name: test_sensors[sensor.energy_site_grid_power-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'distance',
-      'friendly_name': 'Test Battery range ideal',
+      'device_class': 'power',
+      'friendly_name': 'Energy Site Grid power',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_battery_range_ideal',
+    'entity_id': 'sensor.energy_site_grid_power',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '424.35182592',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_charge_energy_added-entry]
+# name: test_sensors[sensor.energy_site_grid_services_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
     'capabilities': dict({
-      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
     }),
     'config_entry_id': <ANY>,
     'device_class': None,
@@ -235,7 +241,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_charge_energy_added',
+    'entity_id': 'sensor.energy_site_grid_services_power',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -245,37 +251,40 @@
     'name': None,
     'options': dict({
       'sensor': dict({
-        'suggested_display_precision': 1,
+        'suggested_display_precision': 2,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Charge energy added',
+    'original_name': 'Grid services power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_charge_energy_added',
-    'unique_id': 'VINVINVIN-charge_state_charge_energy_added',
-    'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
+    'translation_key': 'grid_services_power',
+    'unique_id': '123456-grid_services_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_charge_energy_added-state]
+# name: test_sensors[sensor.energy_site_grid_services_power-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'energy',
-      'friendly_name': 'Test Charge energy added',
-      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
-      'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
+      'device_class': 'power',
+      'friendly_name': 'Energy Site Grid services power',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_charge_energy_added',
+    'entity_id': 'sensor.energy_site_grid_services_power',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '18.47',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_charge_rate-entry]
+# name: test_sensors[sensor.energy_site_load_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -288,8 +297,8 @@
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_charge_rate',
+    'entity_category': None,
+    'entity_id': 'sensor.energy_site_load_power',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -298,38 +307,41 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 2,
+      }),
       'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+        'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.SPEED: 'speed'>,
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Charge rate',
+    'original_name': 'Load power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_charge_rate',
-    'unique_id': 'VINVINVIN-charge_state_charge_rate',
-    'unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+    'translation_key': 'load_power',
+    'unique_id': '123456-load_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_charge_rate-state]
+# name: test_sensors[sensor.energy_site_load_power-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'speed',
-      'friendly_name': 'Test Charge rate',
+      'device_class': 'power',
+      'friendly_name': 'Energy Site Load power',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_charge_rate',
+    'entity_id': 'sensor.energy_site_load_power',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '49.2',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_charger_current-entry]
+# name: test_sensors[sensor.energy_site_percentage_charged-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -342,8 +354,8 @@
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_charger_current',
+    'entity_category': None,
+    'entity_id': 'sensor.energy_site_percentage_charged',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -352,35 +364,38 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 2,
+      }),
     }),
-    'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
+    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
     'original_icon': None,
-    'original_name': 'Charger current',
+    'original_name': 'Percentage charged',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_charger_actual_current',
-    'unique_id': 'VINVINVIN-charge_state_charger_actual_current',
-    'unit_of_measurement': <UnitOfElectricCurrent.AMPERE: 'A'>,
+    'translation_key': 'percentage_charged',
+    'unique_id': '123456-percentage_charged',
+    'unit_of_measurement': '%',
   })
 # ---
-# name: test_sensors[sensor.test_charger_current-state]
+# name: test_sensors[sensor.energy_site_percentage_charged-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'current',
-      'friendly_name': 'Test Charger current',
+      'device_class': 'battery',
+      'friendly_name': 'Energy Site Percentage charged',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfElectricCurrent.AMPERE: 'A'>,
+      'unit_of_measurement': '%',
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_charger_current',
+    'entity_id': 'sensor.energy_site_percentage_charged',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '32',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_charger_power-entry]
+# name: test_sensors[sensor.energy_site_solar_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -394,7 +409,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_charger_power',
+    'entity_id': 'sensor.energy_site_solar_power',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -403,35 +418,41 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 2,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
+      }),
     }),
     'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Charger power',
+    'original_name': 'Solar power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_charger_power',
-    'unique_id': 'VINVINVIN-charge_state_charger_power',
+    'translation_key': 'solar_power',
+    'unique_id': '123456-solar_power',
     'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_charger_power-state]
+# name: test_sensors[sensor.energy_site_solar_power-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
       'device_class': 'power',
-      'friendly_name': 'Test Charger power',
+      'friendly_name': 'Energy Site Solar power',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
       'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_charger_power',
+    'entity_id': 'sensor.energy_site_solar_power',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '7',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_charger_voltage-entry]
+# name: test_sensors[sensor.energy_site_total_pack_energy-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -445,7 +466,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_charger_voltage',
+    'entity_id': 'sensor.energy_site_total_pack_energy',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -454,56 +475,53 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 2,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
+      }),
     }),
-    'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
+    'original_device_class': <SensorDeviceClass.ENERGY_STORAGE: 'energy_storage'>,
     'original_icon': None,
-    'original_name': 'Charger voltage',
+    'original_name': 'Total pack energy',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_charger_voltage',
-    'unique_id': 'VINVINVIN-charge_state_charger_voltage',
-    'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
+    'translation_key': 'total_pack_energy',
+    'unique_id': '123456-total_pack_energy',
+    'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
   })
 # ---
-# name: test_sensors[sensor.test_charger_voltage-state]
+# name: test_sensors[sensor.energy_site_total_pack_energy-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'voltage',
-      'friendly_name': 'Test Charger voltage',
+      'device_class': 'energy_storage',
+      'friendly_name': 'Energy Site Total pack energy',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
+      'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_charger_voltage',
+    'entity_id': 'sensor.energy_site_total_pack_energy',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '224',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_charging-entry]
+# name: test_sensors[sensor.energy_site_vpp_backup_reserve-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
-    'capabilities': dict({
-      'options': list([
-        'starting',
-        'charging',
-        'stopped',
-        'complete',
-        'disconnected',
-        'no_power',
-      ]),
-    }),
+    'capabilities': None,
     'config_entry_id': <ANY>,
     'device_class': None,
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.test_charging',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.energy_site_vpp_backup_reserve',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -513,52 +531,47 @@
     'name': None,
     'options': dict({
     }),
-    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
     'original_icon': None,
-    'original_name': 'Charging',
+    'original_name': 'VPP backup reserve',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_charging_state',
-    'unique_id': 'VINVINVIN-charge_state_charging_state',
-    'unit_of_measurement': None,
+    'translation_key': 'vpp_backup_reserve_percent',
+    'unique_id': '123456-vpp_backup_reserve_percent',
+    'unit_of_measurement': '%',
   })
 # ---
-# name: test_sensors[sensor.test_charging-state]
+# name: test_sensors[sensor.energy_site_vpp_backup_reserve-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'enum',
-      'friendly_name': 'Test Charging',
-      'options': list([
-        'starting',
-        'charging',
-        'stopped',
-        'complete',
-        'disconnected',
-        'no_power',
-      ]),
+      'device_class': 'battery',
+      'friendly_name': 'Energy Site VPP backup reserve',
+      'unit_of_measurement': '%',
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_charging',
+    'entity_id': 'sensor.energy_site_vpp_backup_reserve',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': 'charging',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_destination-entry]
+# name: test_sensors[sensor.test_battery_level-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
-    'capabilities': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
     'config_entry_id': <ANY>,
     'device_class': None,
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_destination',
+    'entity_category': None,
+    'entity_id': 'sensor.test_battery_level',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -568,31 +581,34 @@
     'name': None,
     'options': dict({
     }),
-    'original_device_class': None,
+    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
     'original_icon': None,
-    'original_name': 'Destination',
+    'original_name': 'Battery level',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'drive_state_active_route_destination',
-    'unique_id': 'VINVINVIN-drive_state_active_route_destination',
-    'unit_of_measurement': None,
+    'translation_key': 'charge_state_usable_battery_level',
+    'unique_id': 'VINVINVIN-charge_state_usable_battery_level',
+    'unit_of_measurement': '%',
   })
 # ---
-# name: test_sensors[sensor.test_destination-state]
+# name: test_sensors[sensor.test_battery_level-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'friendly_name': 'Test Destination',
+      'device_class': 'battery',
+      'friendly_name': 'Test Battery level',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': '%',
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_destination',
+    'entity_id': 'sensor.test_battery_level',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': 'Giga Texas',
+    'state': '75',
   })
 # ---
-# name: test_sensors[sensor.test_distance-entry]
+# name: test_sensors[sensor.test_battery_range-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -603,32 +619,53 @@
     'config_entry_id': <ANY>,
     'device_class': None,
     'device_id': <ANY>,
-    'disabled_by': <RegistryEntryDisabler.INTEGRATION: 'integration'>,
+    'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_distance',
+    'entity_id': 'sensor.test_battery_range',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
     'id': <ANY>,
+    'labels': set({
+    }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
       'sensor.private': dict({
         'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
       }),
     }),
     'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
     'original_icon': None,
-    'original_name': 'Distance',
+    'original_name': 'Battery range',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_est_battery_range',
-    'unique_id': 'VINVINVIN-charge_state_est_battery_range',
+    'translation_key': 'charge_state_battery_range',
+    'unique_id': 'VINVINVIN-charge_state_battery_range',
     'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
   })
 # ---
-# name: test_sensors[sensor.test_distance_to_arrival-entry]
+# name: test_sensors[sensor.test_battery_range-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'distance',
+      'friendly_name': 'Test Battery range',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_battery_range',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '424.35182592',
+  })
+# ---
+# name: test_sensors[sensor.test_battery_range_estimate-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -642,7 +679,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_distance_to_arrival',
+    'entity_id': 'sensor.test_battery_range_estimate',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -651,38 +688,41 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
       'sensor.private': dict({
         'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
       }),
     }),
     'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
     'original_icon': None,
-    'original_name': 'Distance to arrival',
+    'original_name': 'Battery range estimate',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'drive_state_active_route_miles_to_arrival',
-    'unique_id': 'VINVINVIN-drive_state_active_route_miles_to_arrival',
+    'translation_key': 'charge_state_est_battery_range',
+    'unique_id': 'VINVINVIN-charge_state_est_battery_range',
     'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
   })
 # ---
-# name: test_sensors[sensor.test_distance_to_arrival-state]
+# name: test_sensors[sensor.test_battery_range_estimate-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
       'device_class': 'distance',
-      'friendly_name': 'Test Distance to arrival',
+      'friendly_name': 'Test Battery range estimate',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
       'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_distance_to_arrival',
+    'entity_id': 'sensor.test_battery_range_estimate',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '75.168198',
+    'state': '522.60227712',
   })
 # ---
-# name: test_sensors[sensor.test_driver_temperature_setting-entry]
+# name: test_sensors[sensor.test_battery_range_ideal-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -695,8 +735,8 @@
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_driver_temperature_setting',
+    'entity_category': None,
+    'entity_id': 'sensor.test_battery_range_ideal',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -708,41 +748,44 @@
       'sensor': dict({
         'suggested_display_precision': 1,
       }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+      }),
     }),
-    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
     'original_icon': None,
-    'original_name': 'Driver temperature setting',
+    'original_name': 'Battery range ideal',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'climate_state_driver_temp_setting',
-    'unique_id': 'VINVINVIN-climate_state_driver_temp_setting',
-    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    'translation_key': 'charge_state_ideal_battery_range',
+    'unique_id': 'VINVINVIN-charge_state_ideal_battery_range',
+    'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
   })
 # ---
-# name: test_sensors[sensor.test_driver_temperature_setting-state]
+# name: test_sensors[sensor.test_battery_range_ideal-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'temperature',
-      'friendly_name': 'Test Driver temperature setting',
+      'device_class': 'distance',
+      'friendly_name': 'Test Battery range ideal',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+      'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_driver_temperature_setting',
+    'entity_id': 'sensor.test_battery_range_ideal',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '22.5',
+    'state': '424.35182592',
   })
 # ---
-# name: test_sensors[sensor.test_inside_temperature-entry]
+# name: test_sensors[sensor.test_charge_energy_added-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
     'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
     }),
     'config_entry_id': <ANY>,
     'device_class': None,
@@ -750,7 +793,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_inside_temperature',
+    'entity_id': 'sensor.test_charge_energy_added',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -763,40 +806,40 @@
         'suggested_display_precision': 1,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
     'original_icon': None,
-    'original_name': 'Inside temperature',
+    'original_name': 'Charge energy added',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'climate_state_inside_temp',
-    'unique_id': 'VINVINVIN-climate_state_inside_temp',
-    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    'translation_key': 'charge_state_charge_energy_added',
+    'unique_id': 'VINVINVIN-charge_state_charge_energy_added',
+    'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
   })
 # ---
-# name: test_sensors[sensor.test_inside_temperature-state]
+# name: test_sensors[sensor.test_charge_energy_added-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'temperature',
-      'friendly_name': 'Test Inside temperature',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+      'device_class': 'energy',
+      'friendly_name': 'Test Charge energy added',
+      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
+      'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_inside_temperature',
+    'entity_id': 'sensor.test_charge_energy_added',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '30.4',
+    'state': '18.47',
   })
 # ---
-# name: test_sensors[sensor.test_odometer-entry]
+# name: test_sensors[sensor.test_charge_rate-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
     'capabilities': dict({
-      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
     }),
     'config_entry_id': <ANY>,
     'device_class': None,
@@ -804,7 +847,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_odometer',
+    'entity_id': 'sensor.test_charge_rate',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -813,41 +856,38 @@
     }),
     'name': None,
     'options': dict({
-      'sensor': dict({
-        'suggested_display_precision': 0,
-      }),
       'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+        'suggested_unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
+    'original_device_class': <SensorDeviceClass.SPEED: 'speed'>,
     'original_icon': None,
-    'original_name': 'Odometer',
+    'original_name': 'Charge rate',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'vehicle_state_odometer',
-    'unique_id': 'VINVINVIN-vehicle_state_odometer',
-    'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+    'translation_key': 'charge_state_charge_rate',
+    'unique_id': 'VINVINVIN-charge_state_charge_rate',
+    'unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
   })
 # ---
-# name: test_sensors[sensor.test_odometer-state]
+# name: test_sensors[sensor.test_charge_rate-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'distance',
-      'friendly_name': 'Test Odometer',
-      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
-      'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+      'device_class': 'speed',
+      'friendly_name': 'Test Charge rate',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_odometer',
+    'entity_id': 'sensor.test_charge_rate',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '8778.15941765875',
+    'state': '49.2',
   })
 # ---
-# name: test_sensors[sensor.test_outside_temperature-entry]
+# name: test_sensors[sensor.test_charger_current-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -860,8 +900,8 @@
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': None,
-    'entity_id': 'sensor.test_outside_temperature',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_charger_current',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -870,38 +910,35 @@
     }),
     'name': None,
     'options': dict({
-      'sensor': dict({
-        'suggested_display_precision': 1,
-      }),
     }),
-    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
     'original_icon': None,
-    'original_name': 'Outside temperature',
+    'original_name': 'Charger current',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'climate_state_outside_temp',
-    'unique_id': 'VINVINVIN-climate_state_outside_temp',
-    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    'translation_key': 'charge_state_charger_actual_current',
+    'unique_id': 'VINVINVIN-charge_state_charger_actual_current',
+    'unit_of_measurement': <UnitOfElectricCurrent.AMPERE: 'A'>,
   })
 # ---
-# name: test_sensors[sensor.test_outside_temperature-state]
+# name: test_sensors[sensor.test_charger_current-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'temperature',
-      'friendly_name': 'Test Outside temperature',
+      'device_class': 'current',
+      'friendly_name': 'Test Charger current',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+      'unit_of_measurement': <UnitOfElectricCurrent.AMPERE: 'A'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_outside_temperature',
+    'entity_id': 'sensor.test_charger_current',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '30.5',
+    'state': '32',
   })
 # ---
-# name: test_sensors[sensor.test_passenger_temperature_setting-entry]
+# name: test_sensors[sensor.test_charger_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -914,8 +951,8 @@
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_passenger_temperature_setting',
+    'entity_category': None,
+    'entity_id': 'sensor.test_charger_power',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -924,38 +961,35 @@
     }),
     'name': None,
     'options': dict({
-      'sensor': dict({
-        'suggested_display_precision': 1,
-      }),
     }),
-    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Passenger temperature setting',
+    'original_name': 'Charger power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'climate_state_passenger_temp_setting',
-    'unique_id': 'VINVINVIN-climate_state_passenger_temp_setting',
-    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    'translation_key': 'charge_state_charger_power',
+    'unique_id': 'VINVINVIN-charge_state_charger_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_passenger_temperature_setting-state]
+# name: test_sensors[sensor.test_charger_power-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'temperature',
-      'friendly_name': 'Test Passenger temperature setting',
+      'device_class': 'power',
+      'friendly_name': 'Test Charger power',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_passenger_temperature_setting',
+    'entity_id': 'sensor.test_charger_power',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '22.5',
+    'state': '7',
   })
 # ---
-# name: test_sensors[sensor.test_power-entry]
+# name: test_sensors[sensor.test_charger_voltage-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -969,7 +1003,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_power',
+    'entity_id': 'sensor.test_charger_voltage',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -979,44 +1013,46 @@
     'name': None,
     'options': dict({
     }),
-    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
+    'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
     'original_icon': None,
-    'original_name': 'Power',
+    'original_name': 'Charger voltage',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'drive_state_power',
-    'unique_id': 'VINVINVIN-drive_state_power',
-    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
+    'translation_key': 'charge_state_charger_voltage',
+    'unique_id': 'VINVINVIN-charge_state_charger_voltage',
+    'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
   })
 # ---
-# name: test_sensors[sensor.test_power-state]
+# name: test_sensors[sensor.test_charger_voltage-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'power',
-      'friendly_name': 'Test Power',
+      'device_class': 'voltage',
+      'friendly_name': 'Test Charger voltage',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
+      'unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_power',
+    'entity_id': 'sensor.test_charger_voltage',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '-7',
+    'state': '224',
   })
 # ---
-# name: test_sensors[sensor.test_shift_state-entry]
+# name: test_sensors[sensor.test_charging-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
     'capabilities': dict({
       'options': list([
-        'p',
-        'd',
-        'r',
-        'n',
+        'starting',
+        'charging',
+        'stopped',
+        'complete',
+        'disconnected',
+        'no_power',
       ]),
     }),
     'config_entry_id': <ANY>,
@@ -1025,7 +1061,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_shift_state',
+    'entity_id': 'sensor.test_charging',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1037,36 +1073,84 @@
     }),
     'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
     'original_icon': None,
-    'original_name': 'Shift state',
+    'original_name': 'Charging',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'drive_state_shift_state',
-    'unique_id': 'VINVINVIN-drive_state_shift_state',
+    'translation_key': 'charge_state_charging_state',
+    'unique_id': 'VINVINVIN-charge_state_charging_state',
     'unit_of_measurement': None,
   })
 # ---
-# name: test_sensors[sensor.test_shift_state-state]
+# name: test_sensors[sensor.test_charging-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
       'device_class': 'enum',
-      'friendly_name': 'Test Shift state',
+      'friendly_name': 'Test Charging',
       'options': list([
-        'p',
-        'd',
-        'r',
-        'n',
+        'starting',
+        'charging',
+        'stopped',
+        'complete',
+        'disconnected',
+        'no_power',
       ]),
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_shift_state',
+    'entity_id': 'sensor.test_charging',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': 'unknown',
+    'state': 'charging',
   })
 # ---
-# name: test_sensors[sensor.test_speed-entry]
+# name: test_sensors[sensor.test_destination-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_destination',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Destination',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'drive_state_active_route_destination',
+    'unique_id': 'VINVINVIN-drive_state_active_route_destination',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensors[sensor.test_destination-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Test Destination',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_destination',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'Giga Texas',
+  })
+# ---
+# name: test_sensors[sensor.test_distance_to_arrival-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -1080,7 +1164,758 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_speed',
+    'entity_id': 'sensor.test_distance_to_arrival',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
+    'original_icon': None,
+    'original_name': 'Distance to arrival',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'drive_state_active_route_miles_to_arrival',
+    'unique_id': 'VINVINVIN-drive_state_active_route_miles_to_arrival',
+    'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+  })
+# ---
+# name: test_sensors[sensor.test_distance_to_arrival-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'distance',
+      'friendly_name': 'Test Distance to arrival',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_distance_to_arrival',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '75.168198',
+  })
+# ---
+# name: test_sensors[sensor.test_driver_temperature_setting-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_driver_temperature_setting',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_icon': None,
+    'original_name': 'Driver temperature setting',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'climate_state_driver_temp_setting',
+    'unique_id': 'VINVINVIN-climate_state_driver_temp_setting',
+    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+  })
+# ---
+# name: test_sensors[sensor.test_driver_temperature_setting-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'temperature',
+      'friendly_name': 'Test Driver temperature setting',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_driver_temperature_setting',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '22.5',
+  })
+# ---
+# name: test_sensors[sensor.test_inside_temperature-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.test_inside_temperature',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_icon': None,
+    'original_name': 'Inside temperature',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'climate_state_inside_temp',
+    'unique_id': 'VINVINVIN-climate_state_inside_temp',
+    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+  })
+# ---
+# name: test_sensors[sensor.test_inside_temperature-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'temperature',
+      'friendly_name': 'Test Inside temperature',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_inside_temperature',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '30.4',
+  })
+# ---
+# name: test_sensors[sensor.test_odometer-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_odometer',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 0,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
+    'original_icon': None,
+    'original_name': 'Odometer',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'vehicle_state_odometer',
+    'unique_id': 'VINVINVIN-vehicle_state_odometer',
+    'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+  })
+# ---
+# name: test_sensors[sensor.test_odometer-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'distance',
+      'friendly_name': 'Test Odometer',
+      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
+      'unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_odometer',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '8778.15941765875',
+  })
+# ---
+# name: test_sensors[sensor.test_outside_temperature-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.test_outside_temperature',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_icon': None,
+    'original_name': 'Outside temperature',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'climate_state_outside_temp',
+    'unique_id': 'VINVINVIN-climate_state_outside_temp',
+    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+  })
+# ---
+# name: test_sensors[sensor.test_outside_temperature-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'temperature',
+      'friendly_name': 'Test Outside temperature',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_outside_temperature',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '30.5',
+  })
+# ---
+# name: test_sensors[sensor.test_passenger_temperature_setting-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_passenger_temperature_setting',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
+    'original_icon': None,
+    'original_name': 'Passenger temperature setting',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'climate_state_passenger_temp_setting',
+    'unique_id': 'VINVINVIN-climate_state_passenger_temp_setting',
+    'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+  })
+# ---
+# name: test_sensors[sensor.test_passenger_temperature_setting-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'temperature',
+      'friendly_name': 'Test Passenger temperature setting',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_passenger_temperature_setting',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '22.5',
+  })
+# ---
+# name: test_sensors[sensor.test_power-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_power',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
+    'original_icon': None,
+    'original_name': 'Power',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'drive_state_power',
+    'unique_id': 'VINVINVIN-drive_state_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
+  })
+# ---
+# name: test_sensors[sensor.test_power-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'power',
+      'friendly_name': 'Test Power',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_power',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '-7',
+  })
+# ---
+# name: test_sensors[sensor.test_shift_state-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        'p',
+        'd',
+        'r',
+        'n',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.test_shift_state',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
+    'original_icon': None,
+    'original_name': 'Shift state',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'drive_state_shift_state',
+    'unique_id': 'VINVINVIN-drive_state_shift_state',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensors[sensor.test_shift_state-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'enum',
+      'friendly_name': 'Test Shift state',
+      'options': list([
+        'p',
+        'd',
+        'r',
+        'n',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_shift_state',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'unknown',
+  })
+# ---
+# name: test_sensors[sensor.test_speed-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.test_speed',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.SPEED: 'speed'>,
+    'original_icon': None,
+    'original_name': 'Speed',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'drive_state_speed',
+    'unique_id': 'VINVINVIN-drive_state_speed',
+    'unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+  })
+# ---
+# name: test_sensors[sensor.test_speed-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'speed',
+      'friendly_name': 'Test Speed',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_speed',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'unknown',
+  })
+# ---
+# name: test_sensors[sensor.test_state_of_charge_at_arrival-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_state_of_charge_at_arrival',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
+    'original_icon': None,
+    'original_name': 'State of charge at arrival',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'drive_state_active_route_energy_at_arrival',
+    'unique_id': 'VINVINVIN-drive_state_active_route_energy_at_arrival',
+    'unit_of_measurement': '%',
+  })
+# ---
+# name: test_sensors[sensor.test_state_of_charge_at_arrival-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'battery',
+      'friendly_name': 'Test State of charge at arrival',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': '%',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_state_of_charge_at_arrival',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '65',
+  })
+# ---
+# name: test_sensors[sensor.test_time_to_arrival-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.test_time_to_arrival',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.TIMESTAMP: 'timestamp'>,
+    'original_icon': None,
+    'original_name': 'Time to arrival',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'drive_state_active_route_minutes_to_arrival',
+    'unique_id': 'VINVINVIN-drive_state_active_route_minutes_to_arrival',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensors[sensor.test_time_to_arrival-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'timestamp',
+      'friendly_name': 'Test Time to arrival',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_time_to_arrival',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '2024-01-01T00:59:12+00:00',
+  })
+# ---
+# name: test_sensors[sensor.test_time_to_full_charge-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_time_to_full_charge',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.TIMESTAMP: 'timestamp'>,
+    'original_icon': None,
+    'original_name': 'Time to full charge',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'charge_state_minutes_to_full_charge',
+    'unique_id': 'VINVINVIN-charge_state_minutes_to_full_charge',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_sensors[sensor.test_time_to_full_charge-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'timestamp',
+      'friendly_name': 'Test Time to full charge',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_time_to_full_charge',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'unknown',
+  })
+# ---
+# name: test_sensors[sensor.test_tire_pressure_front_left-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_tire_pressure_front_left',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
+    'original_icon': None,
+    'original_name': 'Tire pressure front left',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'vehicle_state_tpms_pressure_fl',
+    'unique_id': 'VINVINVIN-vehicle_state_tpms_pressure_fl',
+    'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+  })
+# ---
+# name: test_sensors[sensor.test_tire_pressure_front_left-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'pressure',
+      'friendly_name': 'Test Tire pressure front left',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_tire_pressure_front_left',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '43.1487288094417',
+  })
+# ---
+# name: test_sensors[sensor.test_tire_pressure_front_right-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_tire_pressure_front_right',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
+    'original_icon': None,
+    'original_name': 'Tire pressure front right',
+    'platform': 'tessie',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': 'vehicle_state_tpms_pressure_fr',
+    'unique_id': 'VINVINVIN-vehicle_state_tpms_pressure_fr',
+    'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+  })
+# ---
+# name: test_sensors[sensor.test_tire_pressure_front_right-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'pressure',
+      'friendly_name': 'Test Tire pressure front right',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.test_tire_pressure_front_right',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '43.1487288094417',
+  })
+# ---
+# name: test_sensors[sensor.test_tire_pressure_rear_left-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.test_tire_pressure_rear_left',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1089,38 +1924,41 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
       'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+        'suggested_unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.SPEED: 'speed'>,
+    'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
     'original_icon': None,
-    'original_name': 'Speed',
+    'original_name': 'Tire pressure rear left',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'drive_state_speed',
-    'unique_id': 'VINVINVIN-drive_state_speed',
-    'unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+    'translation_key': 'vehicle_state_tpms_pressure_rl',
+    'unique_id': 'VINVINVIN-vehicle_state_tpms_pressure_rl',
+    'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
   })
 # ---
-# name: test_sensors[sensor.test_speed-state]
+# name: test_sensors[sensor.test_tire_pressure_rear_left-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'speed',
-      'friendly_name': 'Test Speed',
+      'device_class': 'pressure',
+      'friendly_name': 'Test Tire pressure rear left',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
+      'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_speed',
+    'entity_id': 'sensor.test_tire_pressure_rear_left',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': 'unknown',
+    'state': '42.7861344496985',
   })
 # ---
-# name: test_sensors[sensor.test_state_of_charge_at_arrival-entry]
+# name: test_sensors[sensor.test_tire_pressure_rear_right-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -1134,7 +1972,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_state_of_charge_at_arrival',
+    'entity_id': 'sensor.test_tire_pressure_rear_right',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1143,47 +1981,55 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 1,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+      }),
     }),
-    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
+    'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
     'original_icon': None,
-    'original_name': 'State of charge at arrival',
+    'original_name': 'Tire pressure rear right',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'drive_state_active_route_energy_at_arrival',
-    'unique_id': 'VINVINVIN-drive_state_active_route_energy_at_arrival',
-    'unit_of_measurement': '%',
+    'translation_key': 'vehicle_state_tpms_pressure_rr',
+    'unique_id': 'VINVINVIN-vehicle_state_tpms_pressure_rr',
+    'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
   })
 # ---
-# name: test_sensors[sensor.test_state_of_charge_at_arrival-state]
+# name: test_sensors[sensor.test_tire_pressure_rear_right-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'battery',
-      'friendly_name': 'Test State of charge at arrival',
+      'device_class': 'pressure',
+      'friendly_name': 'Test Tire pressure rear right',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': '%',
+      'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_state_of_charge_at_arrival',
+    'entity_id': 'sensor.test_tire_pressure_rear_right',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '65',
+    'state': '42.7861344496985',
   })
 # ---
-# name: test_sensors[sensor.test_time_to_arrival-entry]
+# name: test_sensors[sensor.test_traffic_delay-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
-    'capabilities': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
     'config_entry_id': <ANY>,
     'device_class': None,
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_time_to_arrival',
+    'entity_id': 'sensor.test_traffic_delay',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1193,44 +2039,48 @@
     'name': None,
     'options': dict({
     }),
-    'original_device_class': <SensorDeviceClass.TIMESTAMP: 'timestamp'>,
+    'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
     'original_icon': None,
-    'original_name': 'Time to arrival',
+    'original_name': 'Traffic delay',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'drive_state_active_route_minutes_to_arrival',
-    'unique_id': 'VINVINVIN-drive_state_active_route_minutes_to_arrival',
-    'unit_of_measurement': None,
+    'translation_key': 'drive_state_active_route_traffic_minutes_delay',
+    'unique_id': 'VINVINVIN-drive_state_active_route_traffic_minutes_delay',
+    'unit_of_measurement': <UnitOfTime.MINUTES: 'min'>,
   })
 # ---
-# name: test_sensors[sensor.test_time_to_arrival-state]
+# name: test_sensors[sensor.test_traffic_delay-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'timestamp',
-      'friendly_name': 'Test Time to arrival',
+      'device_class': 'duration',
+      'friendly_name': 'Test Traffic delay',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfTime.MINUTES: 'min'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_time_to_arrival',
+    'entity_id': 'sensor.test_traffic_delay',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '2024-01-01T00:59:12+00:00',
+    'state': '0',
   })
 # ---
-# name: test_sensors[sensor.test_time_to_full_charge-entry]
+# name: test_sensors[sensor.wall_connector_power-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
-    'capabilities': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
     'config_entry_id': <ANY>,
     'device_class': None,
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_time_to_full_charge',
+    'entity_category': None,
+    'entity_id': 'sensor.wall_connector_power',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1239,33 +2089,41 @@
     }),
     'name': None,
     'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 2,
+      }),
+      'sensor.private': dict({
+        'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
+      }),
     }),
-    'original_device_class': <SensorDeviceClass.TIMESTAMP: 'timestamp'>,
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Time to full charge',
+    'original_name': 'Power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'charge_state_minutes_to_full_charge',
-    'unique_id': 'VINVINVIN-charge_state_minutes_to_full_charge',
-    'unit_of_measurement': None,
+    'translation_key': 'wall_connector_power',
+    'unique_id': '123456-abd-123-wall_connector_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_time_to_full_charge-state]
+# name: test_sensors[sensor.wall_connector_power-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'timestamp',
-      'friendly_name': 'Test Time to full charge',
+      'device_class': 'power',
+      'friendly_name': 'Wall Connector Power',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_time_to_full_charge',
+    'entity_id': 'sensor.wall_connector_power',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
     'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_tire_pressure_front_left-entry]
+# name: test_sensors[sensor.wall_connector_power_2-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
@@ -1278,8 +2136,8 @@
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_tire_pressure_front_left',
+    'entity_category': None,
+    'entity_id': 'sensor.wall_connector_power_2',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1289,46 +2147,57 @@
     'name': None,
     'options': dict({
       'sensor': dict({
-        'suggested_display_precision': 1,
+        'suggested_display_precision': 2,
       }),
       'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+        'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
       }),
     }),
-    'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
+    'original_device_class': <SensorDeviceClass.POWER: 'power'>,
     'original_icon': None,
-    'original_name': 'Tire pressure front left',
+    'original_name': 'Power',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'vehicle_state_tpms_pressure_fl',
-    'unique_id': 'VINVINVIN-vehicle_state_tpms_pressure_fl',
-    'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+    'translation_key': 'wall_connector_power',
+    'unique_id': '123456-bcd-234-wall_connector_power',
+    'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
   })
 # ---
-# name: test_sensors[sensor.test_tire_pressure_front_left-state]
+# name: test_sensors[sensor.wall_connector_power_2-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'pressure',
-      'friendly_name': 'Test Tire pressure front left',
+      'device_class': 'power',
+      'friendly_name': 'Wall Connector Power',
       'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+      'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_tire_pressure_front_left',
+    'entity_id': 'sensor.wall_connector_power_2',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '43.1487288094417',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_tire_pressure_front_right-entry]
+# name: test_sensors[sensor.wall_connector_state-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
     'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'options': list([
+        'booting',
+        'charging',
+        'disconnected',
+        'connected',
+        'scheduled',
+        'negotiating',
+        'error',
+        'charging_finished',
+        'waiting_car',
+        'charging_reduced',
+      ]),
     }),
     'config_entry_id': <ANY>,
     'device_class': None,
@@ -1336,7 +2205,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_tire_pressure_front_right',
+    'entity_id': 'sensor.wall_connector_state',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1345,47 +2214,62 @@
     }),
     'name': None,
     'options': dict({
-      'sensor': dict({
-        'suggested_display_precision': 1,
-      }),
-      'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
-      }),
     }),
-    'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
     'original_icon': None,
-    'original_name': 'Tire pressure front right',
+    'original_name': 'State',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'vehicle_state_tpms_pressure_fr',
-    'unique_id': 'VINVINVIN-vehicle_state_tpms_pressure_fr',
-    'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+    'translation_key': 'wall_connector_state',
+    'unique_id': '123456-abd-123-wall_connector_state',
+    'unit_of_measurement': None,
   })
 # ---
-# name: test_sensors[sensor.test_tire_pressure_front_right-state]
+# name: test_sensors[sensor.wall_connector_state-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'pressure',
-      'friendly_name': 'Test Tire pressure front right',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+      'device_class': 'enum',
+      'friendly_name': 'Wall Connector State',
+      'options': list([
+        'booting',
+        'charging',
+        'disconnected',
+        'connected',
+        'scheduled',
+        'negotiating',
+        'error',
+        'charging_finished',
+        'waiting_car',
+        'charging_reduced',
+      ]),
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_tire_pressure_front_right',
+    'entity_id': 'sensor.wall_connector_state',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '43.1487288094417',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_tire_pressure_rear_left-entry]
+# name: test_sensors[sensor.wall_connector_state_2-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
     'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'options': list([
+        'booting',
+        'charging',
+        'disconnected',
+        'connected',
+        'scheduled',
+        'negotiating',
+        'error',
+        'charging_finished',
+        'waiting_car',
+        'charging_reduced',
+      ]),
     }),
     'config_entry_id': <ANY>,
     'device_class': None,
@@ -1393,7 +2277,7 @@
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_tire_pressure_rear_left',
+    'entity_id': 'sensor.wall_connector_state_2',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1402,55 +2286,57 @@
     }),
     'name': None,
     'options': dict({
-      'sensor': dict({
-        'suggested_display_precision': 1,
-      }),
-      'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
-      }),
     }),
-    'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
+    'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
     'original_icon': None,
-    'original_name': 'Tire pressure rear left',
+    'original_name': 'State',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'vehicle_state_tpms_pressure_rl',
-    'unique_id': 'VINVINVIN-vehicle_state_tpms_pressure_rl',
-    'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+    'translation_key': 'wall_connector_state',
+    'unique_id': '123456-bcd-234-wall_connector_state',
+    'unit_of_measurement': None,
   })
 # ---
-# name: test_sensors[sensor.test_tire_pressure_rear_left-state]
+# name: test_sensors[sensor.wall_connector_state_2-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'pressure',
-      'friendly_name': 'Test Tire pressure rear left',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+      'device_class': 'enum',
+      'friendly_name': 'Wall Connector State',
+      'options': list([
+        'booting',
+        'charging',
+        'disconnected',
+        'connected',
+        'scheduled',
+        'negotiating',
+        'error',
+        'charging_finished',
+        'waiting_car',
+        'charging_reduced',
+      ]),
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_tire_pressure_rear_left',
+    'entity_id': 'sensor.wall_connector_state_2',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '42.7861344496985',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_tire_pressure_rear_right-entry]
+# name: test_sensors[sensor.wall_connector_vehicle-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
-    'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-    }),
+    'capabilities': None,
     'config_entry_id': <ANY>,
     'device_class': None,
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'sensor.test_tire_pressure_rear_right',
+    'entity_category': None,
+    'entity_id': 'sensor.wall_connector_vehicle',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1459,55 +2345,44 @@
     }),
     'name': None,
     'options': dict({
-      'sensor': dict({
-        'suggested_display_precision': 1,
-      }),
-      'sensor.private': dict({
-        'suggested_unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
-      }),
     }),
-    'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
+    'original_device_class': None,
     'original_icon': None,
-    'original_name': 'Tire pressure rear right',
+    'original_name': 'Vehicle',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'vehicle_state_tpms_pressure_rr',
-    'unique_id': 'VINVINVIN-vehicle_state_tpms_pressure_rr',
-    'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+    'translation_key': 'vin',
+    'unique_id': '123456-abd-123-vin',
+    'unit_of_measurement': None,
   })
 # ---
-# name: test_sensors[sensor.test_tire_pressure_rear_right-state]
+# name: test_sensors[sensor.wall_connector_vehicle-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'pressure',
-      'friendly_name': 'Test Tire pressure rear right',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfPressure.PSI: 'psi'>,
+      'friendly_name': 'Wall Connector Vehicle',
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_tire_pressure_rear_right',
+    'entity_id': 'sensor.wall_connector_vehicle',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '42.7861344496985',
+    'state': 'unknown',
   })
 # ---
-# name: test_sensors[sensor.test_traffic_delay-entry]
+# name: test_sensors[sensor.wall_connector_vehicle_2-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
     }),
     'area_id': None,
-    'capabilities': dict({
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-    }),
+    'capabilities': None,
     'config_entry_id': <ANY>,
     'device_class': None,
     'device_id': <ANY>,
     'disabled_by': None,
     'domain': 'sensor',
     'entity_category': None,
-    'entity_id': 'sensor.test_traffic_delay',
+    'entity_id': 'sensor.wall_connector_vehicle_2',
     'has_entity_name': True,
     'hidden_by': None,
     'icon': None,
@@ -1517,30 +2392,27 @@
     'name': None,
     'options': dict({
     }),
-    'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
+    'original_device_class': None,
     'original_icon': None,
-    'original_name': 'Traffic delay',
+    'original_name': 'Vehicle',
     'platform': 'tessie',
     'previous_unique_id': None,
     'supported_features': 0,
-    'translation_key': 'drive_state_active_route_traffic_minutes_delay',
-    'unique_id': 'VINVINVIN-drive_state_active_route_traffic_minutes_delay',
-    'unit_of_measurement': <UnitOfTime.MINUTES: 'min'>,
+    'translation_key': 'vin',
+    'unique_id': '123456-bcd-234-vin',
+    'unit_of_measurement': None,
   })
 # ---
-# name: test_sensors[sensor.test_traffic_delay-state]
+# name: test_sensors[sensor.wall_connector_vehicle_2-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'duration',
-      'friendly_name': 'Test Traffic delay',
-      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
-      'unit_of_measurement': <UnitOfTime.MINUTES: 'min'>,
+      'friendly_name': 'Wall Connector Vehicle',
     }),
     'context': <ANY>,
-    'entity_id': 'sensor.test_traffic_delay',
+    'entity_id': 'sensor.wall_connector_vehicle_2',
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': '0',
+    'state': 'unknown',
   })
 # ---
diff --git a/tests/components/tessie/test_coordinator.py b/tests/components/tessie/test_coordinator.py
index c4c1b6d1e72fc45fa5e4d0b91c4ffe3043f59363..77b2829b53a63783de1386ef061301cb5e9414da 100644
--- a/tests/components/tessie/test_coordinator.py
+++ b/tests/components/tessie/test_coordinator.py
@@ -2,11 +2,17 @@
 
 from datetime import timedelta
 
+from freezegun.api import FrozenDateTimeFactory
+from tesla_fleet_api.exceptions import Forbidden, InvalidToken
+
 from homeassistant.components.tessie import PLATFORMS
-from homeassistant.components.tessie.coordinator import TESSIE_SYNC_INTERVAL
+from homeassistant.components.tessie.coordinator import (
+    TESSIE_FLEET_API_SYNC_INTERVAL,
+    TESSIE_SYNC_INTERVAL,
+)
+from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.util.dt import utcnow
 
 from .common import (
     ERROR_AUTH,
@@ -22,60 +28,124 @@ WAIT = timedelta(seconds=TESSIE_SYNC_INTERVAL)
 
 
 async def test_coordinator_online(
-    hass: HomeAssistant, mock_get_state, mock_get_status
+    hass: HomeAssistant, mock_get_state, mock_get_status, freezer: FrozenDateTimeFactory
 ) -> None:
     """Tests that the coordinator handles online vehicles."""
 
     await setup_platform(hass, PLATFORMS)
 
-    async_fire_time_changed(hass, utcnow() + WAIT)
+    freezer.tick(WAIT)
+    async_fire_time_changed(hass)
     await hass.async_block_till_done()
     mock_get_status.assert_called_once()
     mock_get_state.assert_called_once()
     assert hass.states.get("binary_sensor.test_status").state == STATE_ON
 
 
-async def test_coordinator_asleep(hass: HomeAssistant, mock_get_status) -> None:
+async def test_coordinator_asleep(
+    hass: HomeAssistant, mock_get_status, freezer: FrozenDateTimeFactory
+) -> None:
     """Tests that the coordinator handles asleep vehicles."""
 
     await setup_platform(hass, [Platform.BINARY_SENSOR])
     mock_get_status.return_value = TEST_VEHICLE_STATUS_ASLEEP
 
-    async_fire_time_changed(hass, utcnow() + WAIT)
+    freezer.tick(WAIT)
+    async_fire_time_changed(hass)
     await hass.async_block_till_done()
     mock_get_status.assert_called_once()
     assert hass.states.get("binary_sensor.test_status").state == STATE_OFF
 
 
-async def test_coordinator_clienterror(hass: HomeAssistant, mock_get_status) -> None:
+async def test_coordinator_clienterror(
+    hass: HomeAssistant, mock_get_status, freezer: FrozenDateTimeFactory
+) -> None:
     """Tests that the coordinator handles client errors."""
 
     mock_get_status.side_effect = ERROR_UNKNOWN
     await setup_platform(hass, [Platform.BINARY_SENSOR])
 
-    async_fire_time_changed(hass, utcnow() + WAIT)
+    freezer.tick(WAIT)
+    async_fire_time_changed(hass)
     await hass.async_block_till_done()
     mock_get_status.assert_called_once()
     assert hass.states.get("binary_sensor.test_status").state == STATE_UNAVAILABLE
 
 
-async def test_coordinator_auth(hass: HomeAssistant, mock_get_status) -> None:
-    """Tests that the coordinator handles timeout errors."""
+async def test_coordinator_auth(
+    hass: HomeAssistant, mock_get_status, freezer: FrozenDateTimeFactory
+) -> None:
+    """Tests that the coordinator handles auth errors."""
 
     mock_get_status.side_effect = ERROR_AUTH
     await setup_platform(hass, [Platform.BINARY_SENSOR])
 
-    async_fire_time_changed(hass, utcnow() + WAIT)
+    freezer.tick(WAIT)
+    async_fire_time_changed(hass)
     await hass.async_block_till_done()
     mock_get_status.assert_called_once()
 
 
-async def test_coordinator_connection(hass: HomeAssistant, mock_get_status) -> None:
+async def test_coordinator_connection(
+    hass: HomeAssistant, mock_get_status, freezer: FrozenDateTimeFactory
+) -> None:
     """Tests that the coordinator handles connection errors."""
 
     mock_get_status.side_effect = ERROR_CONNECTION
     await setup_platform(hass, [Platform.BINARY_SENSOR])
-    async_fire_time_changed(hass, utcnow() + WAIT)
+    freezer.tick(WAIT)
+    async_fire_time_changed(hass)
     await hass.async_block_till_done()
     mock_get_status.assert_called_once()
     assert hass.states.get("binary_sensor.test_status").state == STATE_UNAVAILABLE
+
+
+async def test_coordinator_live_error(
+    hass: HomeAssistant, mock_live_status, freezer: FrozenDateTimeFactory
+) -> None:
+    """Tests that the energy live coordinator handles fleet errors."""
+
+    await setup_platform(hass, [Platform.SENSOR])
+
+    mock_live_status.reset_mock()
+    mock_live_status.side_effect = Forbidden
+    freezer.tick(TESSIE_FLEET_API_SYNC_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+    mock_live_status.assert_called_once()
+    assert hass.states.get("sensor.energy_site_solar_power").state == STATE_UNAVAILABLE
+
+
+async def test_coordinator_info_error(
+    hass: HomeAssistant, mock_site_info, freezer: FrozenDateTimeFactory
+) -> None:
+    """Tests that the energy info coordinator handles fleet errors."""
+
+    await setup_platform(hass, [Platform.SENSOR])
+
+    mock_site_info.reset_mock()
+    mock_site_info.side_effect = Forbidden
+    freezer.tick(TESSIE_FLEET_API_SYNC_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+    mock_site_info.assert_called_once()
+    assert (
+        hass.states.get("sensor.energy_site_vpp_backup_reserve").state
+        == STATE_UNAVAILABLE
+    )
+
+
+async def test_coordinator_live_reauth(hass: HomeAssistant, mock_live_status) -> None:
+    """Tests that the energy live coordinator handles auth errors."""
+
+    mock_live_status.side_effect = InvalidToken
+    entry = await setup_platform(hass, [Platform.SENSOR])
+    assert entry.state is ConfigEntryState.SETUP_ERROR
+
+
+async def test_coordinator_info_reauth(hass: HomeAssistant, mock_site_info) -> None:
+    """Tests that the energy info coordinator handles auth errors."""
+
+    mock_site_info.side_effect = InvalidToken
+    entry = await setup_platform(hass, [Platform.SENSOR])
+    assert entry.state is ConfigEntryState.SETUP_ERROR
diff --git a/tests/components/tessie/test_init.py b/tests/components/tessie/test_init.py
index 81d1d758edf82272fcbbe483984da6ff0c936456..e37512ea8c48ddc9d45321e20cbde296d93d6ca8 100644
--- a/tests/components/tessie/test_init.py
+++ b/tests/components/tessie/test_init.py
@@ -1,5 +1,9 @@
 """Test the Tessie init."""
 
+from unittest.mock import patch
+
+from tesla_fleet_api.exceptions import TeslaFleetError
+
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 
@@ -44,3 +48,13 @@ async def test_connection_failure(
     mock_get_state_of_all_vehicles.side_effect = ERROR_CONNECTION
     entry = await setup_platform(hass)
     assert entry.state is ConfigEntryState.SETUP_RETRY
+
+
+async def test_fleet_error(hass: HomeAssistant) -> None:
+    """Test init with a fleet error."""
+
+    with patch(
+        "homeassistant.components.tessie.Tessie.products", side_effect=TeslaFleetError
+    ):
+        entry = await setup_platform(hass)
+        assert entry.state is ConfigEntryState.SETUP_RETRY