Add openevse config flow (#158968)

Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>

CODEOWNERS

@@ -1170,6 +1170,8 @@ build.json @home-assistant/supervisor
 /tests/components/open_router/ @joostlek
 /homeassistant/components/openerz/ @misialq
 /tests/components/openerz/ @misialq
+/homeassistant/components/openevse/ @c00w
+/tests/components/openevse/ @c00w
 /homeassistant/components/openexchangerates/ @MartinHjelmare
 /tests/components/openexchangerates/ @MartinHjelmare
 /homeassistant/components/opengarage/ @danielhiversen

homeassistant/components/openevse/__init__.py

@@ -1 +1,30 @@
-"""The openevse component."""
+"""The OpenEVSE integration."""
+
+from __future__ import annotations
+
+import openevsewifi
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+
+type OpenEVSEConfigEntry = ConfigEntry[openevsewifi.Charger]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: OpenEVSEConfigEntry) -> bool:
+    """Set up openevse from a config entry."""
+
+    entry.runtime_data = openevsewifi.Charger(entry.data[CONF_HOST])
+    try:
+        await hass.async_add_executor_job(entry.runtime_data.getStatus)
+    except AttributeError as ex:
+        raise ConfigEntryError("Unable to connect to charger") from ex
+
+    await hass.config_entries.async_forward_entry_setups(entry, [Platform.SENSOR])
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, [Platform.SENSOR])

homeassistant/components/openevse/config_flow.py

@@ -0,0 +1,64 @@
+"""Config flow for OpenEVSE integration."""
+
+from typing import Any
+
+import openevsewifi
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_HOST
+
+from .const import DOMAIN
+
+
+class OpenEVSEConfigFlow(ConfigFlow, domain=DOMAIN):
+    """OpenEVSE config flow."""
+
+    VERSION = 1
+    MINOR_VERSION = 1
+
+    async def check_status(self, host: str) -> bool:
+        """Check if we can connect to the OpenEVSE charger."""
+
+        charger = openevsewifi.Charger(host)
+        try:
+            result = await self.hass.async_add_executor_job(charger.getStatus)
+        except AttributeError:
+            return False
+        else:
+            return result is not None
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+
+        errors = None
+        if user_input is not None:
+            self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
+
+            if await self.check_status(user_input[CONF_HOST]):
+                return self.async_create_entry(
+                    title=f"OpenEVSE {user_input[CONF_HOST]}",
+                    data=user_input,
+                )
+            errors = {CONF_HOST: "cannot_connect"}
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema({vol.Required(CONF_HOST): str}),
+            errors=errors,
+        )
+
+    async def async_step_import(self, data: dict[str, str]) -> ConfigFlowResult:
+        """Handle the initial step."""
+
+        self._async_abort_entries_match({CONF_HOST: data[CONF_HOST]})
+
+        if not await self.check_status(data[CONF_HOST]):
+            return self.async_abort(reason="unavailable_host")
+
+        return self.async_create_entry(
+            title=f"OpenEVSE {data[CONF_HOST]}",
+            data=data,
+        )

homeassistant/components/openevse/const.py

@@ -0,0 +1,4 @@
+"""Constants for the OpenEVSE integration."""
+
+DOMAIN = "openevse"
+INTEGRATION_TITLE = "OpenEVSE"

homeassistant/components/openevse/manifest.json

@@ -1,8 +1,10 @@
 {
   "domain": "openevse",
   "name": "OpenEVSE",
-  "codeowners": [],
+  "codeowners": ["@c00w"],
+  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/openevse",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["openevsewifi"],
   "quality_scale": "legacy",

homeassistant/components/openevse/sensor.py

@@ -9,12 +9,14 @@ from requests import RequestException
 import voluptuous as vol
 
 from homeassistant.components.sensor import (
+    DOMAIN as HOMEASSISTANT_DOMAIN,
     PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
     SensorStateClass,
 )
+from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.const import (
     CONF_HOST,
     CONF_MONITORED_VARIABLES,
@@ -23,10 +25,17 @@ from homeassistant.const import (
     UnitOfTime,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.data_entry_flow import FlowResultType
+from homeassistant.helpers import config_validation as cv, issue_registry as ir
+from homeassistant.helpers.entity_platform import (
+    AddConfigEntryEntitiesCallback,
+    AddEntitiesCallback,
+)
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
+from . import ConfigEntry
+from .const import DOMAIN, INTEGRATION_TITLE
+
 _LOGGER = logging.getLogger(__name__)
 
 SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
@@ -54,6 +63,7 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
         key="rtc_temp",
@@ -61,6 +71,7 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
         key="usage_session",
@@ -90,33 +101,86 @@ PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
 )
 
 
-def setup_platform(
+async def async_setup_platform(
     hass: HomeAssistant,
     config: ConfigType,
-    add_entities: AddEntitiesCallback,
+    async_add_entities: AddEntitiesCallback,
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
-    """Set up the OpenEVSE sensor."""
-    host = config[CONF_HOST]
-    monitored_variables = config[CONF_MONITORED_VARIABLES]
+    """Set up the openevse platform."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_IMPORT},
+        data=config,
+    )
 
-    charger = openevsewifi.Charger(host)
+    if (
+        result.get("type") is FlowResultType.ABORT
+        and result.get("reason") != "already_configured"
+    ):
+        ir.async_create_issue(
+            hass,
+            DOMAIN,
+            f"deprecated_yaml_import_issue_{result.get('reason')}",
+            breaks_in_ha_version="2026.6.0",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key=f"deprecated_yaml_import_issue_{result.get('reason')}",
+            translation_placeholders={
+                "domain": DOMAIN,
+                "integration_title": INTEGRATION_TITLE,
+            },
+        )
+        return
 
-    entities = [
-        OpenEVSESensor(charger, description)
-        for description in SENSOR_TYPES
-        if description.key in monitored_variables
-    ]
+    ir.async_create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        "deprecated_yaml",
+        breaks_in_ha_version="2026.7.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=ir.IssueSeverity.WARNING,
+        translation_key="deprecated_yaml",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": INTEGRATION_TITLE,
+        },
+    )
 
-    add_entities(entities, True)
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Add sensors for passed config_entry in HA."""
+    async_add_entities(
+        (
+            OpenEVSESensor(
+                config_entry.data[CONF_HOST],
+                config_entry.runtime_data,
+                description,
+            )
+            for description in SENSOR_TYPES
+        ),
+        True,
+    )
 
 
 class OpenEVSESensor(SensorEntity):
     """Implementation of an OpenEVSE sensor."""
 
-    def __init__(self, charger, description: SensorEntityDescription) -> None:
+    def __init__(
+        self,
+        host: str,
+        charger: openevsewifi.Charger,
+        description: SensorEntityDescription,
+    ) -> None:
         """Initialize the sensor."""
         self.entity_description = description
+        self.host = host
         self.charger = charger
 
     def update(self) -> None:

homeassistant/components/openevse/strings.json

@@ -0,0 +1,27 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "This charger is already configured",
+      "unavailable_host": "Unable to connect to host"
+    },
+    "error": {
+      "cannot_connect": "Unable to connect"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]"
+        },
+        "data_description": {
+          "host": "Enter the IP Address of your openevse. Should match the address you used to set it up."
+        }
+      }
+    }
+  },
+  "issues": {
+    "yaml_deprecated": {
+      "description": "Configuring OpenEVSE using YAML is being removed. Your existing YAML configuration has been imported into the UI automatically. Remove the `openevse` configuration from your configuration.yaml file and restart Home Assistant to fix this issue.",
+      "title": "OpenEVSE YAML configuration is deprecated"
+    }
+  }
+}

homeassistant/generated/config_flows.py

@@ -486,6 +486,7 @@ FLOWS = {
         "open_meteo",
         "open_router",
         "openai_conversation",
+        "openevse",
         "openexchangerates",
         "opengarage",
         "openhome",

homeassistant/generated/integrations.json

@@ -4761,8 +4761,8 @@
     },
     "openevse": {
       "name": "OpenEVSE",
-      "integration_type": "hub",
-      "config_flow": false,
+      "integration_type": "device",
+      "config_flow": true,
       "iot_class": "local_polling"
     },
     "openexchangerates": {

requirements_test_all.txt

@@ -1445,6 +1445,9 @@ openai==2.11.0
 # homeassistant.components.openerz
 openerz-api==0.3.0
 
+# homeassistant.components.openevse
+openevsewifi==1.1.2
+
 # homeassistant.components.openhome
 openhomedevice==2.2.0
 

tests/components/openevse/__init__.py

@@ -0,0 +1 @@
+"""Tests for OpenEVSE component."""

tests/components/openevse/conftest.py

@@ -0,0 +1,53 @@
+"""Test Fixtures for the OpenEVSE tests."""
+
+from collections.abc import Generator
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from homeassistant.components.openevse.const import DOMAIN
+from homeassistant.const import CONF_HOST
+
+from tests.common import MockConfigEntry
+
+
+@pytest.fixture
+def mock_charger() -> Generator[MagicMock]:
+    """Create a mock OpenEVSE charger."""
+    with (
+        patch(
+            "homeassistant.components.openevse.openevsewifi.Charger",
+            autospec=True,
+        ) as mock,
+        patch(
+            "homeassistant.components.openevse.config_flow.openevsewifi.Charger",
+            new=mock,
+        ),
+    ):
+        charger = mock.return_value
+        charger.getStatus.return_value = "Charging"
+        charger.getChargeTimeElapsed.return_value = 3600  # 60 minutes in seconds
+        charger.getAmbientTemperature.return_value = 25.5
+        charger.getIRTemperature.return_value = 30.2
+        charger.getRTCTemperature.return_value = 28.7
+        charger.getUsageSession.return_value = 15000  # 15 kWh in Wh
+        charger.getUsageTotal.return_value = 500000  # 500 kWh in Wh
+        charger.charging_current = 32.0
+        yield charger
+
+
+@pytest.fixture
+def mock_setup_entry() -> Generator[AsyncMock]:
+    """Mock setting up a config entry."""
+    with patch(
+        "homeassistant.components.openevse.async_setup_entry", return_value=True
+    ) as mock_setup_entry:
+        yield mock_setup_entry
+
+
+@pytest.fixture
+def mock_config_entry() -> MockConfigEntry:
+    """Create a mock config entry."""
+    return MockConfigEntry(
+        domain=DOMAIN, data={CONF_HOST: "192.168.1.100"}, entry_id="FAKE"
+    )

tests/components/openevse/test_config_flow.py

@@ -0,0 +1,139 @@
+"""Tests for the OpenEVSE sensor platform."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+from homeassistant.components.openevse.const import DOMAIN
+from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_USER
+from homeassistant.const import CONF_HOST
+from homeassistant.core import HomeAssistant
+from homeassistant.data_entry_flow import FlowResultType
+
+
+async def test_user_flow(
+    hass: HomeAssistant,
+    mock_charger: MagicMock,
+    mock_setup_entry: AsyncMock,
+) -> None:
+    """Test user flow create entry with bad charger."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_USER},
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_HOST: "10.0.0.131"},
+    )
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "OpenEVSE 10.0.0.131"
+    assert result["data"] == {
+        CONF_HOST: "10.0.0.131",
+    }
+
+
+async def test_user_flow_flaky(
+    hass: HomeAssistant,
+    mock_charger: MagicMock,
+    mock_setup_entry: AsyncMock,
+) -> None:
+    """Test user flow create entry with flaky charger."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_USER},
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+    mock_charger.getStatus.side_effect = AttributeError
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_HOST: "10.0.0.131"},
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+    assert result["errors"] == {"host": "cannot_connect"}
+
+    mock_charger.getStatus.side_effect = "Charging"
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_HOST: "10.0.0.131"},
+    )
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "OpenEVSE 10.0.0.131"
+    assert result["data"] == {
+        CONF_HOST: "10.0.0.131",
+    }
+
+
+async def test_user_flow_duplicate(
+    hass: HomeAssistant,
+    mock_config_entry: MagicMock,
+    mock_charger: MagicMock,
+    mock_setup_entry: AsyncMock,
+) -> None:
+    """Test user flow aborts when config entry already exists."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_USER},
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_HOST: "192.168.1.100"},
+    )
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"
+
+
+async def test_import_flow(
+    hass: HomeAssistant,
+    mock_charger: MagicMock,
+    mock_setup_entry: AsyncMock,
+) -> None:
+    """Test import flow."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_IMPORT}, data={CONF_HOST: "10.0.0.131"}
+    )
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == "OpenEVSE 10.0.0.131"
+    assert result["data"] == {
+        CONF_HOST: "10.0.0.131",
+    }
+
+
+async def test_import_flow_bad(
+    hass: HomeAssistant,
+    mock_charger: MagicMock,
+    mock_setup_entry: AsyncMock,
+) -> None:
+    """Test import flow with bad charger."""
+    mock_charger.getStatus.side_effect = AttributeError
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_IMPORT}, data={CONF_HOST: "10.0.0.131"}
+    )
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "unavailable_host"
+
+
+async def test_import_flow_duplicate(
+    hass: HomeAssistant,
+    mock_config_entry: MagicMock,
+    mock_charger: MagicMock,
+    mock_setup_entry: AsyncMock,
+) -> None:
+    """Test import flow aborts when config entry already exists."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_IMPORT},
+        data={CONF_HOST: "192.168.1.100"},
+    )
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"

tests/components/openevse/test_sensor.py

@@ -0,0 +1,47 @@
+"""Tests for the OpenEVSE sensor platform."""
+
+from unittest.mock import MagicMock
+
+from homeassistant.core import HomeAssistant
+
+from tests.common import MockConfigEntry
+
+
+async def test_sensor_setup(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_charger: MagicMock,
+) -> None:
+    """Test setting up the sensor platform."""
+    mock_config_entry.add_to_hass(hass)
+
+    assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    state = hass.states.get("sensor.charging_status")
+    assert state is not None
+    assert state.state == "Charging"
+
+    state = hass.states.get("sensor.charge_time_elapsed")
+    assert state is not None
+    assert state.state == "60.0"
+
+    state = hass.states.get("sensor.ambient_temperature")
+    assert state is not None
+    assert state.state == "25.5"
+
+    state = hass.states.get("sensor.usage_this_session")
+    assert state is not None
+    assert state.state == "15.0"
+
+    state = hass.states.get("sensor.total_usage")
+    assert state is not None
+    assert state.state == "500.0"
+
+    state = hass.states.get("sensor.ir_temperature")
+    assert state is not None
+    assert state.state == "30.2"
+
+    state = hass.states.get("sensor.rtc_temperature")
+    assert state is not None
+    assert state.state == "28.7"